WIP - configure list views

.env.web

@@ -1,5 +1,5 @@
 NUXT_PORT=3001
 NUXT_HOST=0.0.0.0
 
-# Nitro BFF backend URL (server-only, not exposed to client)
-BACKEND_URL=https://backend.routebox.co
+# Point Nuxt to the API container (not localhost)
+NUXT_PUBLIC_API_BASE_URL=https://tenant1.routebox.co

backend/migrations/tenant/20250131000001_add_layout_type_to_page_layouts.js

@@ -2,94 +2,24 @@
  * @param { import("knex").Knex } knex
  * @returns { Promise<void> }
  */
-exports.up = async function(knex) {
-  // Check if layout_type column already exists (in case of partial migration)
-  const hasLayoutType = await knex.schema.hasColumn('page_layouts', 'layout_type');
-  
-  // Check if the old index exists
-  const [indexes] = await knex.raw(`SHOW INDEX FROM page_layouts WHERE Key_name = 'page_layouts_object_id_is_default_index'`);
-  const hasOldIndex = indexes.length > 0;
-
-  // Check if foreign key exists
-  const [fks] = await knex.raw(`
-    SELECT CONSTRAINT_NAME FROM information_schema.TABLE_CONSTRAINTS 
-    WHERE TABLE_SCHEMA = DATABASE() 
-    AND TABLE_NAME = 'page_layouts' 
-    AND CONSTRAINT_TYPE = 'FOREIGN KEY'
-    AND CONSTRAINT_NAME = 'page_layouts_object_id_foreign'
-  `);
-  const hasForeignKey = fks.length > 0;
-
-  if (hasOldIndex) {
-    // First, drop the foreign key constraint that depends on the index (if it exists)
-    if (hasForeignKey) {
-      await knex.schema.alterTable('page_layouts', (table) => {
-        table.dropForeign(['object_id']);
-      });
-    }
-
-    // Now we can safely drop the old index
-    await knex.schema.alterTable('page_layouts', (table) => {
-      table.dropIndex(['object_id', 'is_default']);
-    });
-  }
-
-  // Add layout_type column if it doesn't exist
-  if (!hasLayoutType) {
-    await knex.schema.alterTable('page_layouts', (table) => {
-      // Add layout_type column to distinguish between detail/edit layouts and list view layouts
-      // Default to 'detail' for existing layouts
-      table.enum('layout_type', ['detail', 'list']).notNullable().defaultTo('detail').after('name');
-    });
-  }
-
-  // Check if new index exists
-  const [newIndexes] = await knex.raw(`SHOW INDEX FROM page_layouts WHERE Key_name = 'page_layouts_object_id_layout_type_is_default_index'`);
-  const hasNewIndex = newIndexes.length > 0;
-
-  if (!hasNewIndex) {
-    // Create new index including layout_type
-    await knex.schema.alterTable('page_layouts', (table) => {
-      table.index(['object_id', 'layout_type', 'is_default']);
-    });
-  }
-
-  // Re-check if foreign key exists (may have been dropped above or in previous attempt)
-  const [fksAfter] = await knex.raw(`
-    SELECT CONSTRAINT_NAME FROM information_schema.TABLE_CONSTRAINTS 
-    WHERE TABLE_SCHEMA = DATABASE() 
-    AND TABLE_NAME = 'page_layouts' 
-    AND CONSTRAINT_TYPE = 'FOREIGN KEY'
-    AND CONSTRAINT_NAME = 'page_layouts_object_id_foreign'
-  `);
-  
-  if (fksAfter.length === 0) {
-    // Re-add the foreign key constraint
-    await knex.schema.alterTable('page_layouts', (table) => {
-      table.foreign('object_id').references('id').inTable('object_definitions').onDelete('CASCADE');
-    });
-  }
+exports.up = function(knex) {
+  return knex.schema.alterTable('page_layouts', (table) => {
+    // Add layout_type column to distinguish between detail/edit layouts and list view layouts
+    // Default to 'detail' for existing layouts
+    table.enum('layout_type', ['detail', 'list']).notNullable().defaultTo('detail').after('name');
+    
+    // Update the unique index to include layout_type so we can have both a default detail and default list layout
+    table.dropIndex(['object_id', 'is_default']);
+  });
 };
 
 /**
  * @param { import("knex").Knex } knex
  * @returns { Promise<void> }
  */
-exports.down = async function(knex) {
-  // Drop the foreign key first
-  await knex.schema.alterTable('page_layouts', (table) => {
-    table.dropForeign(['object_id']);
-  });
-
-  // Drop the new index and column, restore old index
-  await knex.schema.alterTable('page_layouts', (table) => {
-    table.dropIndex(['object_id', 'layout_type', 'is_default']);
+exports.down = function(knex) {
+  return knex.schema.alterTable('page_layouts', (table) => {
     table.dropColumn('layout_type');
     table.index(['object_id', 'is_default']);
   });
-
-  // Re-add the foreign key constraint
-  await knex.schema.alterTable('page_layouts', (table) => {
-    table.foreign('object_id').references('id').inTable('object_definitions').onDelete('CASCADE');
-  });
 };

backend/migrations/tenant/20260410000001_create_saved_list_views.js

@@ -1,55 +0,0 @@
-/**
- * Creates the saved_list_views table.
- * Each row stores a named, reusable search/filter configuration for a specific
- * CRM object type. Views can be private to the owning user or shared with the
- * whole tenant.
- *
- * @param { import("knex").Knex } knex
- * @returns { Promise<void> }
- */
-exports.up = function (knex) {
-  return knex.schema.createTable('saved_list_views', (table) => {
-    table.uuid('id').primary().defaultTo(knex.raw('(UUID())'));
-
-    // Human-readable name given by the user (or AI-suggested)
-    table.string('name').notNullable();
-
-    // The object this view belongs to (e.g. "Dog", "Contact")
-    table.string('object_api_name').notNullable();
-
-    // The user who created/owns this view
-    table.uuid('user_id').notNullable();
-
-    // When true the view is visible to all users in the tenant
-    table.boolean('is_shared').notNullable().defaultTo(false);
-
-    // Strategy is always "query" for saved views (keyword views are not saved)
-    table.string('strategy').notNullable().defaultTo('query');
-
-    // Resolved filters as JSON array of AiSearchFilter objects
-    table.json('filters').notNullable();
-
-    // Optional sort: { field: string, direction: "asc" | "desc" }
-    table.json('sort').nullable();
-
-    // AI-generated plain-language explanation of what this view shows
-    table.text('description').nullable();
-
-    table.timestamps(true, true);
-
-    // Foreign key to users
-    table.foreign('user_id').references('id').inTable('users').onDelete('CASCADE');
-
-    // Primary lookup: all views for an object visible to a user
-    table.index(['object_api_name', 'user_id']);
-    table.index(['object_api_name', 'is_shared']);
-  });
-};
-
-/**
- * @param { import("knex").Knex } knex
- * @returns { Promise<void> }
- */
-exports.down = function (knex) {
-  return knex.schema.dropTableIfExists('saved_list_views');
-};

backend/migrations/tenant/20260410000002_add_saved_list_view_object_definition.js

@@ -1,35 +0,0 @@
-/**
- * Inserts a system object_definition row for SavedListView.
- * This allows saved_list_views records to be shared via record_shares
- * (which requires a valid objectDefinitionId FK).
- *
- * @param { import("knex").Knex } knex
- * @returns { Promise<void> }
- */
-exports.up = async function (knex) {
-  // Only insert if it doesn't already exist (idempotent)
-  const existing = await knex('object_definitions')
-    .where({ apiName: 'SavedListView' })
-    .first();
-
-  if (!existing) {
-    await knex('object_definitions').insert({
-      apiName: 'SavedListView',
-      label: 'Saved List View',
-      pluralLabel: 'Saved List Views',
-      description: 'System object for sharing saved list views via record_shares',
-      isSystem: true,
-      isCustom: false,
-    });
-  }
-};
-
-/**
- * @param { import("knex").Knex } knex
- * @returns { Promise<void> }
- */
-exports.down = async function (knex) {
-  await knex('object_definitions')
-    .where({ apiName: 'SavedListView' })
-    .delete();
-};

backend/migrations/tenant/20260410000003_add_alias_and_name_to_users.js

@@ -1,30 +0,0 @@
-/**
- * Add 'alias' and virtual 'name' column to users table.
- * 
- * - alias: a user-editable display name / nickname
- * - name:  a generated column that returns COALESCE(alias, CONCAT(firstName, ' ', lastName), email)
- *          so that lookup fields referencing User.name always resolve.
- */
-exports.up = function (knex) {
-  return knex.schema.alterTable('users', (table) => {
-    table.string('alias', 255).nullable().after('lastName');
-    table.string('name', 512).nullable().after('alias');
-  }).then(() => {
-    // Backfill existing rows: name = alias, or firstName + lastName, or email
-    return knex.raw(`
-      UPDATE users
-      SET name = COALESCE(
-        NULLIF(alias, ''),
-        NULLIF(TRIM(CONCAT(COALESCE(firstName, ''), ' ', COALESCE(lastName, ''))), ''),
-        email
-      )
-    `);
-  });
-};
-
-exports.down = function (knex) {
-  return knex.schema.alterTable('users', (table) => {
-    table.dropColumn('name');
-    table.dropColumn('alias');
-  });
-};

backend/migrations/tenant/20260411000001_create_knowledge_layer_tables.js

@@ -1,93 +0,0 @@
-/**
- * @param { import("knex").Knex } knex
- * @returns { Promise<void> }
- */
-exports.up = async function (knex) {
-  await knex.schema.createTable('comments', (table) => {
-    table.uuid('id').primary().defaultTo(knex.raw('(UUID())'));
-    table.string('parent_object_api_name').notNullable();
-    table.uuid('parent_record_id').notNullable();
-    table.uuid('author_user_id').notNullable();
-    table.text('content').notNullable();
-    table.timestamps(true, true);
-
-    table.foreign('author_user_id').references('id').inTable('users').onDelete('CASCADE');
-    table.index(['parent_object_api_name', 'parent_record_id'], 'comments_parent_idx');
-    table.index(['author_user_id'], 'comments_author_idx');
-  });
-
-  await knex.schema.createTable('semantic_documents', (table) => {
-    table.uuid('id').primary().defaultTo(knex.raw('(UUID())'));
-    table.string('entity_type').notNullable();
-    table.uuid('entity_id').notNullable();
-    table.string('title').nullable();
-    table.text('narrative').nullable();
-    table.json('metadata').nullable();
-    table.json('source_summary').nullable();
-    table.timestamps(true, true);
-
-    table.unique(['entity_type', 'entity_id'], {
-      indexName: 'semantic_documents_entity_unique',
-    });
-    table.index(['entity_type'], 'semantic_documents_type_idx');
-  });
-
-  await knex.schema.createTable('semantic_chunks', (table) => {
-    table.uuid('id').primary().defaultTo(knex.raw('(UUID())'));
-    table.uuid('semantic_document_id').notNullable();
-    table.integer('chunk_index').notNullable();
-    table.string('source_kind').notNullable().defaultTo('base_record');
-    table.uuid('source_ref_id').nullable();
-    table.text('text').notNullable();
-    table.json('metadata').nullable();
-    table.timestamps(true, true);
-
-    table.foreign('semantic_document_id').references('id').inTable('semantic_documents').onDelete('CASCADE');
-    table.unique(['semantic_document_id', 'chunk_index'], {
-      indexName: 'semantic_chunks_doc_index_unique',
-    });
-    table.index(['semantic_document_id'], 'semantic_chunks_document_idx');
-    table.index(['source_kind'], 'semantic_chunks_source_kind_idx');
-  });
-
-  await knex.schema.createTable('semantic_links', (table) => {
-    table.uuid('id').primary().defaultTo(knex.raw('(UUID())'));
-    table.string('source_entity_type', 100).notNullable();
-    table.uuid('source_entity_id').notNullable();
-    table.string('target_entity_type', 100).notNullable();
-    table.uuid('target_entity_id').notNullable();
-    table.string('link_type', 100).notNullable().defaultTo('related_to');
-    table.string('status').notNullable().defaultTo('suggested');
-    table.string('origin').notNullable().defaultTo('semantic');
-    table.decimal('confidence', 5, 4).notNullable().defaultTo(0);
-    table.text('reason').nullable();
-    table.json('evidence').nullable();
-    table.uuid('suggested_by_user_id').nullable();
-    table.uuid('reviewed_by_user_id').nullable();
-    table.timestamp('reviewed_at').nullable();
-    table.timestamps(true, true);
-
-    table.foreign('suggested_by_user_id').references('id').inTable('users').onDelete('SET NULL');
-    table.foreign('reviewed_by_user_id').references('id').inTable('users').onDelete('SET NULL');
-
-    table.unique(
-      ['source_entity_type', 'source_entity_id', 'target_entity_type', 'target_entity_id', 'link_type'],
-      { indexName: 'semantic_links_unique_pair_type' },
-    );
-
-    table.index(['source_entity_type', 'source_entity_id'], 'semantic_links_source_idx');
-    table.index(['target_entity_type', 'target_entity_id'], 'semantic_links_target_idx');
-    table.index(['status'], 'semantic_links_status_idx');
-  });
-};
-
-/**
- * @param { import("knex").Knex } knex
- * @returns { Promise<void> }
- */
-exports.down = async function (knex) {
-  await knex.schema.dropTableIfExists('semantic_links');
-  await knex.schema.dropTableIfExists('semantic_chunks');
-  await knex.schema.dropTableIfExists('semantic_documents');
-  await knex.schema.dropTableIfExists('comments');
-};

backend/prisma/schema.prisma

@@ -20,8 +20,6 @@ model User {
   password  String
   firstName String?
   lastName  String?
-  alias     String?
-  name      String?
   isActive  Boolean  @default(true)
   createdAt DateTime @default(now())
   updatedAt DateTime @updatedAt

backend/src/ai-assistant/ai-assistant.controller.ts

@@ -38,12 +38,4 @@ export class AiAssistantController {
       payload,
     );
   }
-
-  @Post('suggest-view-name')
-  async suggestViewName(
-    @TenantId() tenantId: string,
-    @Body() payload: { objectLabel: string; filters: any[]; explanation?: string },
-  ) {
-    return this.aiAssistantService.suggestViewName(tenantId, payload);
-  }
 }

backend/src/ai-assistant/ai-assistant.service.ts

@@ -49,7 +49,7 @@ type AiSearchPayload = {
 @Injectable()
 export class AiAssistantService {
   private readonly logger = new Logger(AiAssistantService.name);
-  private readonly defaultModel = process.env.OPENAI_MODEL || 'gpt-5.4-mini';
+  private readonly defaultModel = process.env.OPENAI_MODEL || 'gpt-4o';
   private readonly conversationState = new Map<
     string,
     { fields: Record<string, any>; updatedAt: number }
@@ -688,8 +688,6 @@ export class AiAssistantService {
           totalCount: meiliResults.total ?? records.totalCount ?? 0,
           strategy: plan.strategy,
           explanation: plan.explanation,
-          filters: [],
-          sort: null,
         };
       }
 
@@ -704,28 +702,16 @@ export class AiAssistantService {
         ...fallback,
         strategy: plan.strategy,
         explanation: plan.explanation,
-        filters: [],
-        sort: null,
       };
     }
 
     console.log('AI search plan (query):', plan);
 
-    // Resolve any LOOKUP filter values (user typed a name, we find the related record ID)
-    const resolvedFilters = await this.resolveRelatedFilters(
-      resolvedTenantId,
-      userId,
-      objectDefinition,
-      plan.filters || [],
-    );
-
-    console.log('Resolved filters for query strategy:', resolvedFilters);
-
     const filtered = await this.objectService.searchRecordsWithFilters(
       resolvedTenantId,
       payload.objectApiName,
       userId,
-      resolvedFilters,
+      plan.filters || [],
       { page, pageSize },
       plan.sort || undefined,
     );
@@ -734,53 +720,9 @@ export class AiAssistantService {
       ...filtered,
       strategy: plan.strategy,
       explanation: plan.explanation,
-      filters: resolvedFilters,
-      sort: plan.sort || null,
     };
   }
 
-  /**
-   * Asks the LLM to suggest a short, human-friendly name for a saved list view
-   * based on the resolved filters / explanation.
-   */
-  async suggestViewName(
-    tenantId: string,
-    payload: { objectLabel: string; filters: AiSearchFilter[]; explanation?: string },
-  ): Promise<{ suggestedName: string }> {
-    const openAiConfig = await this.getOpenAiConfig(tenantId);
-    if (!openAiConfig) {
-      return { suggestedName: `${payload.objectLabel} View` };
-    }
-
-    const model = new ChatOpenAI({
-      apiKey: openAiConfig.apiKey,
-      model: this.normalizeChatModel(openAiConfig.model),
-      temperature: 0.4,
-    });
-
-    const filterSummary = payload.explanation?.trim()
-      || payload.filters.map(f => `${f.field} ${f.operator} ${f.value ?? ''}`).join(', ')
-      || 'no filters';
-
-    try {
-      const response = await model.invoke([
-        new SystemMessage(
-          'You are a CRM assistant. Suggest a very short (2–5 words), descriptive, and human-friendly name for a saved list view. ' +
-          'Reply with ONLY the name, no quotes or punctuation.',
-        ),
-        new HumanMessage(
-          `Object: ${payload.objectLabel}.\nFilter summary: ${filterSummary}`,
-        ),
-      ]);
-
-      const raw = typeof response.content === 'string' ? response.content.trim() : '';
-      const suggestedName = raw || `${payload.objectLabel} View`;
-      return { suggestedName };
-    } catch {
-      return { suggestedName: `${payload.objectLabel} View` };
-    }
-  }
-
   // ============================================
   // Planning-Based LangGraph Workflow
   // ============================================
@@ -2265,59 +2207,6 @@ export class AiAssistantService {
     return extracted;
   }
 
-  /**
-   * Resolves LOOKUP filter values from human-readable names to actual record IDs.
-   * When the AI produces a filter like { field: "familyId", operator: "eq", value: "Gaona Family" },
-   * this method looks up "Gaona Family" in the referenced object and replaces the value with its ID.
-   */
-  private async resolveRelatedFilters(
-    tenantId: string,
-    userId: string,
-    objectDefinition: any,
-    filters: AiSearchFilter[],
-  ): Promise<AiSearchFilter[]> {
-    if (!filters || filters.length === 0) return filters;
-
-    const lookupFieldMap = new Map<string, string>(); // apiName → referenceObject
-    for (const field of objectDefinition.fields || []) {
-      if (field.type === 'LOOKUP' && field.referenceObject) {
-        lookupFieldMap.set(field.apiName, field.referenceObject);
-      }
-    }
-
-    const resolved: AiSearchFilter[] = [];
-    for (const filter of filters) {
-      const referenceObject = lookupFieldMap.get(filter.field);
-      if (
-        referenceObject &&
-        filter.value &&
-        typeof filter.value === 'string' &&
-        !this.isUuid(filter.value)
-      ) {
-        // Try to resolve the name to an ID in the referenced object
-        try {
-          console.log(`Resolving LOOKUP filter: ${filter.field} → searching "${filter.value}" in ${referenceObject}`);
-          const relatedRecord = await this.searchForExistingRecord(tenantId, userId, referenceObject, filter.value);
-          if (relatedRecord?.id) {
-            console.log(`Resolved "${filter.value}" → ID: ${relatedRecord.id}`);
-            resolved.push({ ...filter, operator: 'eq', value: relatedRecord.id });
-          } else {
-            // Could not resolve; keep as-is so we get 0 results rather than wrong ones
-            console.warn(`Could not resolve related record "${filter.value}" in ${referenceObject}; keeping original filter`);
-            resolved.push(filter);
-          }
-        } catch (err) {
-          this.logger.warn(`Failed to resolve lookup filter for ${filter.field}: ${err.message}`);
-          resolved.push(filter);
-        }
-      } else {
-        resolved.push(filter);
-      }
-    }
-
-    return resolved;
-  }
-
   private async buildSearchPlan(
     tenantId: string,
     message: string,
@@ -2361,65 +2250,25 @@ export class AiAssistantService {
       apiName: field.apiName,
       label: field.label,
       type: field.type,
-      ...(field.referenceObject ? { referenceObject: field.referenceObject } : {}),
     }));
 
     const formatInstructions = parser.getFormatInstructions();
     const today = new Date().toISOString();
 
-    const systemPromptLines = [
-      `You are a CRM search assistant. The user is browsing a list of "${objectDefinition.label || objectDefinition.apiName}" records.`,
-      ``,
-      `Your task: decide whether the user input is a KEYWORD search or a STRUCTURED QUERY, then return the correct JSON plan.`,
-      ``,
-      `=== STRATEGY DECISION RULES ===`,
-      `Use strategy="query" when the user:`,
-      `  - Describes a record attribute or property value (e.g. "list all golden retrievers" → filter the race field)`,
-      `  - Uses phrases like "list all X", "show all X", "find all X", "filter by X", "where X is Y"`,
-      `  - Mentions a specific field value, status, category, type, breed, color, size, or any distinguishing characteristic`,
-      `  - Requests records matching a condition (e.g. "created this week", "price > 100", "active only")`,
-      `  - Asks for sorted or ordered results (e.g. "newest first", "alphabetically")`,
-      ``,
-      `Use strategy="keyword" ONLY when the user types a bare search term with no clear field or attribute intent`,
-      `  - e.g. a lone name or identifier: "rex", "john", "acme corp"`,
-      ``,
-      `=== HOW TO MAP USER LANGUAGE TO FIELDS ===`,
-      `When the user describes a characteristic or property value, find the best-matching field from the Fields list`,
-      `and apply a "contains" filter (or "eq" for exact values). Do NOT fall back to keyword just because the`,
-      `field name is not explicitly mentioned — infer the intent from context.`,
-      ``,
-      `EXAMPLES (Object = Dog, fields include: name, race, size, color, createdAt, familyId[LOOKUP→Family]):`,
-      `  "list all cocker spaniels"        → strategy=query, filter: race contains "cocker spaniel"`,
-      `  "show golden retrievers"           → strategy=query, filter: race contains "golden retriever"`,
-      `  "large dogs"                       → strategy=query, filter: size contains "large"`,
-      `  "dogs added this week"             → strategy=query, filter: createdAt between <monday> <today>`,
-      `  "dogs belonging to Gaona Family"  → strategy=query, filter: familyId eq "Gaona Family"`,
-      `  "rex"                              → strategy=keyword, keyword="rex"`,
-      ``,
-      `=== LOOKUP FIELDS ===`,
-      `Fields with type LOOKUP store a reference (ID) to another object (referenceObject).`,
-      `When the user refers to a related record by its name (e.g. "belonging to Gaona Family"),`,
-      `output the human-readable name as the filter value — the system will resolve it to the correct ID.`,
-      `Use the LOOKUP field apiName (e.g. familyId) as the filter field.`,
-      ``,
-      `=== OUTPUT FORMAT ===`,
-      `Return a JSON object with these keys:`,
-      `  strategy    : "keyword" or "query"`,
-      `  explanation : short plain-language description of what the search does`,
-      `  keyword     : the search term when strategy is "keyword", otherwise null`,
-      `  filters     : array of filter objects for strategy="query" (empty array otherwise)`,
-      `  sort        : {field, direction} when sorting is requested, otherwise null`,
-      ``,
-      `Each filter object: { field: <apiName>, operator: <op>, value?, values?, from?, to? }`,
-      `Valid operators: eq | neq | gt | gte | lt | lte | contains | startsWith | endsWith | in | notIn | isNull | notNull | between`,
-      `Use "between" with {from, to} for date ranges.`,
-      `Only use field apiName values exactly as they appear in the Fields list provided.`,
-      ``,
-      formatInstructions,
-    ].join('\n');
-
     const response = await model.invoke([
-      new SystemMessage(systemPromptLines),
+      new SystemMessage(
+        `You are a CRM search assistant. Decide whether the user input is a keyword search or a structured query.` +
+          `\nReturn a JSON object with keys: strategy, explanation, keyword, filters, sort.` +
+          `\n- strategy must be "keyword" or "query".` +
+          `\n- explanation must be a short sentence explaining the approach.` +
+          `\n- keyword should be the search term when strategy is "keyword", otherwise null.` +
+          `\n- filters is an array of {field, operator, value, values, from, to}.` +
+          `\n- operators must be one of eq, neq, gt, gte, lt, lte, contains, startsWith, endsWith, in, notIn, isNull, notNull, between.` +
+          `\n- Use between with from/to when the user gives date ranges like "yesterday" or "last week".` +
+          `\n- sort should be {field, direction} when sorting is requested.` +
+          `\n- Only use field apiName values exactly as provided.` +
+          `\n${formatInstructions}`,
+      ),
       new HumanMessage(
         `Object: ${objectDefinition.label || objectDefinition.apiName}.\n` +
           `Fields: ${JSON.stringify(fields)}.\n` +
@@ -2430,30 +2279,10 @@ export class AiAssistantService {
 
     const content = typeof response.content === 'string' ? response.content : '{}';
     const parsed = await parser.parse(content);
-    const normalizedPlan = this.normalizeSearchPlan(parsed, message, objectDefinition);
-
-    console.log('AI search plan:', normalizedPlan);
-
-    if (normalizedPlan.strategy === 'query') {
-      const aiExplanation = await this.generateQueryExplanationWithAi(
-        model,
-        message,
-        objectDefinition,
-        normalizedPlan,
-      );
-      if (aiExplanation) {
-        normalizedPlan.explanation = aiExplanation;
-      }
-    }
-
-    return normalizedPlan;
+    return this.normalizeSearchPlan(parsed, message);
   }
 
-  private normalizeSearchPlan(
-    plan: AiSearchPlan,
-    message: string,
-    objectDefinition?: any,
-  ): AiSearchPlan {
+  private normalizeSearchPlan(plan: AiSearchPlan, message: string): AiSearchPlan {
     if (!plan || typeof plan !== 'object') {
       return this.buildSearchPlanFallback(message);
     }
@@ -2473,158 +2302,15 @@ export class AiAssistantService {
       };
     }
 
-    const queryExplanation = this.buildQueryExplanation(
-      message,
-      objectDefinition,
-      Array.isArray(plan.filters) ? plan.filters : [],
-      plan.sort || null,
-    );
-
     return {
       strategy,
-      explanation: queryExplanation || explanation,
+      explanation,
       keyword: null,
       filters: Array.isArray(plan.filters) ? plan.filters : [],
       sort: plan.sort || null,
     };
   }
 
-  private buildQueryExplanation(
-    message: string,
-    objectDefinition: any,
-    filters: AiSearchFilter[],
-    sort: { field: string; direction: 'asc' | 'desc' } | null,
-  ): string {
-    const fieldLabelByApiName = new Map<string, string>(
-      (objectDefinition?.fields || []).map((field: any) => [field.apiName, field.label || field.apiName]),
-    );
-    const objectLabel = objectDefinition?.label || objectDefinition?.apiName || 'records';
-
-    const filterParts = filters
-      .map((filter) => this.describeFilter(filter, fieldLabelByApiName))
-      .filter(Boolean) as string[];
-
-    const sortLabel = sort?.field
-      ? fieldLabelByApiName.get(sort.field) || sort.field
-      : null;
-    const sortPart =
-      sortLabel && sort?.direction
-        ? `sorted by ${sortLabel} (${sort.direction === 'desc' ? 'newest/highest first' : 'oldest/lowest first'})`
-        : '';
-
-    if (filterParts.length > 0 && sortPart) {
-      return `Showing ${objectLabel} where ${filterParts.join(' and ')}, ${sortPart}.`;
-    }
-
-    if (filterParts.length > 0) {
-      return `Showing ${objectLabel} where ${filterParts.join(' and ')}.`;
-    }
-
-    if (sortPart) {
-      return `Showing ${objectLabel} ${sortPart}.`;
-    }
-
-    return `Applied filters based on: "${message.trim()}".`;
-  }
-
-  private describeFilter(filter: AiSearchFilter, fieldLabelByApiName: Map<string, string>): string {
-    const fieldLabel = fieldLabelByApiName.get(filter.field) || filter.field;
-    const formatValue = (value: any) =>
-      value === null || value === undefined || value === ''
-        ? 'empty'
-        : typeof value === 'string'
-          ? `"${value}"`
-          : String(value);
-
-    switch (filter.operator) {
-      case 'eq':
-        return `${fieldLabel} is ${formatValue(filter.value)}`;
-      case 'neq':
-        return `${fieldLabel} is not ${formatValue(filter.value)}`;
-      case 'gt':
-        return `${fieldLabel} is greater than ${formatValue(filter.value)}`;
-      case 'gte':
-        return `${fieldLabel} is at least ${formatValue(filter.value)}`;
-      case 'lt':
-        return `${fieldLabel} is less than ${formatValue(filter.value)}`;
-      case 'lte':
-        return `${fieldLabel} is at most ${formatValue(filter.value)}`;
-      case 'contains':
-        return `${fieldLabel} contains ${formatValue(filter.value)}`;
-      case 'startsWith':
-        return `${fieldLabel} starts with ${formatValue(filter.value)}`;
-      case 'endsWith':
-        return `${fieldLabel} ends with ${formatValue(filter.value)}`;
-      case 'in':
-        return `${fieldLabel} is one of ${(filter.values || []).map(formatValue).join(', ')}`;
-      case 'notIn':
-        return `${fieldLabel} is not one of ${(filter.values || []).map(formatValue).join(', ')}`;
-      case 'isNull':
-        return `${fieldLabel} is empty`;
-      case 'notNull':
-        return `${fieldLabel} is not empty`;
-      case 'between':
-        if (filter.from && filter.to) {
-          return `${fieldLabel} is between ${formatValue(filter.from)} and ${formatValue(filter.to)}`;
-        }
-        if (filter.from) {
-          return `${fieldLabel} is from ${formatValue(filter.from)} onward`;
-        }
-        if (filter.to) {
-          return `${fieldLabel} is up to ${formatValue(filter.to)}`;
-        }
-        return `${fieldLabel} uses a date range filter`;
-      default:
-        return '';
-    }
-  }
-
-  private async generateQueryExplanationWithAi(
-    model: ChatOpenAI,
-    message: string,
-    objectDefinition: any,
-    plan: AiSearchPlan,
-  ): Promise<string | null> {
-    try {
-      const fields = (objectDefinition?.fields || []).map((field: any) => ({
-        apiName: field.apiName,
-        label: field.label || field.apiName,
-      }));
-
-      const response = await model.invoke([
-        new SystemMessage(
-          `You explain CRM list query results in plain language for end users.` +
-            `\nWrite one short sentence (max 25 words).` +
-            `\nDescribe the resulting filters/sort in business language.` +
-            `\nDo NOT mention SQL, JSON, "strategy", "query mode", or AI decision process.` +
-            `\nIf values are present, mention the most important ones clearly.`,
-        ),
-        new HumanMessage(
-          `Object: ${objectDefinition?.label || objectDefinition?.apiName || 'records'}\n` +
-            `User request: ${message}\n` +
-            `Available fields: ${JSON.stringify(fields)}\n` +
-            `Applied filters: ${JSON.stringify(plan.filters || [])}\n` +
-            `Applied sort: ${JSON.stringify(plan.sort || null)}\n` +
-            `Current explanation draft: ${plan.explanation}`,
-        ),
-      ]);
-
-      const content = Array.isArray(response.content)
-        ? response.content
-            .map((part: any) => (typeof part === 'string' ? part : part?.text || ''))
-            .join(' ')
-        : String(response.content || '');
-      const cleaned = content.trim().replace(/\s+/g, ' ');
-
-      console.log('AI-generated query explanation:', cleaned);
-
-      return cleaned || null;
-    } catch (error) {
-      this.logger.warn(`AI query explanation refinement failed: ${error.message}`);
-      return null;
-    }
-  }
-
   private sanitizeUserOwnerFields(
     fields: Record<string, any>,
     fieldDefinitions: any[],

backend/src/app-builder/app-builder.service.ts

@@ -10,14 +10,14 @@ export class AppBuilderService {
 
   // Runtime endpoints
   async getApps(tenantId: string, userId: string) {
-    const knex = await this.tenantDbService.getTenantKnexById(tenantId);
+    const knex = await this.tenantDbService.getTenantKnex(tenantId);
     // For now, return all apps
     // In production, you'd filter by user permissions
     return App.query(knex).withGraphFetched('pages').orderBy('label', 'asc');
   }
 
   async getApp(tenantId: string, slug: string, userId: string) {
-    const knex = await this.tenantDbService.getTenantKnexById(tenantId);
+    const knex = await this.tenantDbService.getTenantKnex(tenantId);
     const app = await App.query(knex)
       .findOne({ slug })
       .withGraphFetched('pages');
@@ -35,7 +35,7 @@ export class AppBuilderService {
     pageSlug: string,
     userId: string,
   ) {
-    const knex = await this.tenantDbService.getTenantKnexById(tenantId);
+    const knex = await this.tenantDbService.getTenantKnex(tenantId);
     const app = await this.getApp(tenantId, appSlug, userId);
 
     const page = await AppPage.query(knex).findOne({
@@ -52,12 +52,12 @@ export class AppBuilderService {
 
   // Setup endpoints
   async getAllApps(tenantId: string) {
-    const knex = await this.tenantDbService.getTenantKnexById(tenantId);
+    const knex = await this.tenantDbService.getTenantKnex(tenantId);
     return App.query(knex).withGraphFetched('pages').orderBy('label', 'asc');
   }
 
   async getAppForSetup(tenantId: string, slug: string) {
-    const knex = await this.tenantDbService.getTenantKnexById(tenantId);
+    const knex = await this.tenantDbService.getTenantKnex(tenantId);
     const app = await App.query(knex)
       .findOne({ slug })
       .withGraphFetched('pages');
@@ -77,7 +77,7 @@ export class AppBuilderService {
       description?: string;
     },
   ) {
-    const knex = await this.tenantDbService.getTenantKnexById(tenantId);
+    const knex = await this.tenantDbService.getTenantKnex(tenantId);
     return App.query(knex).insert({
       ...data,
       displayOrder: 0,
@@ -92,7 +92,7 @@ export class AppBuilderService {
       description?: string;
     },
   ) {
-    const knex = await this.tenantDbService.getTenantKnexById(tenantId);
+    const knex = await this.tenantDbService.getTenantKnex(tenantId);
     const app = await this.getAppForSetup(tenantId, slug);
 
     return App.query(knex).patchAndFetchById(app.id, data);
@@ -109,7 +109,7 @@ export class AppBuilderService {
       sortOrder?: number;
     },
   ) {
-    const knex = await this.tenantDbService.getTenantKnexById(tenantId);
+    const knex = await this.tenantDbService.getTenantKnex(tenantId);
     const app = await this.getAppForSetup(tenantId, appSlug);
 
     return AppPage.query(knex).insert({
@@ -133,7 +133,7 @@ export class AppBuilderService {
       sortOrder?: number;
     },
   ) {
-    const knex = await this.tenantDbService.getTenantKnexById(tenantId);
+    const knex = await this.tenantDbService.getTenantKnex(tenantId);
     const app = await this.getAppForSetup(tenantId, appSlug);
 
     const page = await AppPage.query(knex).findOne({

backend/src/app.module.ts

@@ -1,6 +1,5 @@
 import { Module } from '@nestjs/common';
 import { ConfigModule } from '@nestjs/config';
-import { BullModule } from '@nestjs/bullmq';
 import { PrismaModule } from './prisma/prisma.module';
 import { TenantModule } from './tenant/tenant.module';
 import { AuthModule } from './auth/auth.module';
@@ -10,20 +9,12 @@ import { AppBuilderModule } from './app-builder/app-builder.module';
 import { PageLayoutModule } from './page-layout/page-layout.module';
 import { VoiceModule } from './voice/voice.module';
 import { AiAssistantModule } from './ai-assistant/ai-assistant.module';
-import { SavedListViewModule } from './saved-list-view/saved-list-view.module';
-import { KnowledgeModule } from './knowledge/knowledge.module';
 
 @Module({
   imports: [
     ConfigModule.forRoot({
       isGlobal: true,
     }),
-    BullModule.forRoot({
-      connection: {
-        host: process.env.REDIS_HOST || 'platform-redis',
-        port: parseInt(process.env.REDIS_PORT || '6379', 10),
-      },
-    }),
     PrismaModule,
     TenantModule,
     AuthModule,
@@ -33,8 +24,6 @@ import { KnowledgeModule } from './knowledge/knowledge.module';
     PageLayoutModule,
     VoiceModule,
     AiAssistantModule,
-    SavedListViewModule,
-    KnowledgeModule,
   ],
 })
 export class AppModule {}

backend/src/auth/auth.controller.ts

@@ -1,19 +1,15 @@
 import {
   Controller,
   Post,
-  Get,
   Body,
   UnauthorizedException,
   HttpCode,
   HttpStatus,
   Req,
-  UseGuards,
 } from '@nestjs/common';
 import { IsEmail, IsString, MinLength, IsOptional } from 'class-validator';
 import { AuthService } from './auth.service';
 import { TenantId } from '../tenant/tenant.decorator';
-import { JwtAuthGuard } from './jwt-auth.guard';
-import { CurrentUser } from './current-user.decorator';
 
 class LoginDto {
   @IsEmail()
@@ -115,15 +111,4 @@ export class AuthController {
     // This endpoint exists for consistency and potential future enhancements
     return { message: 'Logged out successfully' };
   }
-
-  @UseGuards(JwtAuthGuard)
-  @Get('me')
-  async me(@CurrentUser() user: any, @TenantId() tenantId: string) {
-    // Return the current authenticated user info
-    return {
-      id: user.userId,
-      email: user.email,
-      tenantId: tenantId || user.tenantId,
-    };
-  }
 }

backend/src/auth/auth.service.ts

@@ -29,8 +29,8 @@ export class AuthService {
     }
 
     // Otherwise, validate as tenant user
-    const tenantDb = await this.tenantDbService.getTenantKnexById(tenantId);
-
+    const tenantDb = await this.tenantDbService.getTenantKnex(tenantId);
+    
     const user = await tenantDb('users')
       .where({ email })
       .first();
@@ -113,7 +113,7 @@ export class AuthService {
     }
 
     // Otherwise, register as tenant user
-    const tenantDb = await this.tenantDbService.getTenantKnexById(tenantId);
+    const tenantDb = await this.tenantDbService.getTenantKnex(tenantId);
     
     const hashedPassword = await bcrypt.hash(password, 10);
 

backend/src/knowledge/adapters/semantic-projection.adapter.ts

@@ -1,89 +0,0 @@
-export type SemanticProjectionInput = {
-  objectApiName: string;
-  record: Record<string, any>;
-  objectDefinition?: any;
-  comments: Array<{ id: string; content: string; author_user_id: string; created_at?: string }>;
-};
-
-export type SemanticProjection = {
-  entityType: string;
-  entityId: string;
-  title: string;
-  narrative: string;
-  /** Plain text used for embedding — no 'key: value' labels, no comments (chunker handles those separately). */
-  embeddingNarrative: string;
-  metadata: Record<string, any>;
-  sourceSummary: {
-    includedFieldCount: number;
-    includedCommentCount: number;
-    includesComments: boolean;
-  };
-};
-
-export interface SemanticProjectionAdapter {
-  supports(objectApiName: string): boolean;
-  buildProjection(input: SemanticProjectionInput): SemanticProjection;
-}
-
-const EXCLUDED_FIELDS = new Set([
-  'id',
-  'created_at',
-  'updated_at',
-  'ownerId',
-  'owner_id',
-  'tenantId',
-  'tenant_id',
-]);
-
-export class DefaultSemanticProjectionAdapter implements SemanticProjectionAdapter {
-  supports(): boolean {
-    return true;
-  }
-
-  buildProjection(input: SemanticProjectionInput): SemanticProjection {
-    const fieldEntries = Object.entries(input.record || {}).filter(([key, value]) => {
-      if (EXCLUDED_FIELDS.has(key)) return false;
-      if (value === null || value === undefined || value === '') return false;
-      return ['string', 'number', 'boolean'].includes(typeof value);
-    });
-
-    const title =
-      input.record?.name ||
-      input.record?.title ||
-      input.record?.subject ||
-      `${input.objectApiName} ${input.record?.id || ''}`.trim();
-
-    
-    const fieldNarrative = fieldEntries
-      .map(([key, value]) => `${key}: ${String(value)}`)
-      .join('\n');
-
-    const commentNarrative = (input.comments || [])
-      .map((comment, index) => `Comment ${index + 1}: ${comment.content}`)
-      .join('\n');
-
-    const narrative = [fieldNarrative, commentNarrative].filter(Boolean).join('\n\n');
-
-    // Plain values only — no 'key:' prefixes. Comments are handled separately by the chunker.
-    const embeddingNarrative = fieldEntries
-      .map(([, value]) => String(value))
-      .join('\n');
-
-    return {
-      entityType: input.objectApiName,
-      entityId: input.record.id,
-      title,
-      narrative,
-      embeddingNarrative,
-      metadata: {
-        objectApiName: input.objectApiName,
-        hasComments: (input.comments || []).length > 0,
-      },
-      sourceSummary: {
-        includedFieldCount: fieldEntries.length,
-        includedCommentCount: (input.comments || []).length,
-        includesComments: (input.comments || []).length > 0,
-      },
-    };
-  }
-}

backend/src/knowledge/dto/comment.dto.ts

@@ -1,24 +0,0 @@
-import { IsNotEmpty, IsOptional, IsString, MaxLength, MinLength } from 'class-validator';
-
-export class CreateCommentDto {
-  @IsString()
-  @IsNotEmpty()
-  parentObjectApiName: string;
-
-  @IsString()
-  @IsNotEmpty()
-  parentRecordId: string;
-
-  @IsString()
-  @MinLength(1)
-  @MaxLength(10000)
-  content: string;
-}
-
-export class UpdateCommentDto {
-  @IsOptional()
-  @IsString()
-  @MinLength(1)
-  @MaxLength(10000)
-  content?: string;
-}

backend/src/knowledge/dto/semantic-link.dto.ts

@@ -1,52 +0,0 @@
-import { IsIn, IsNumber, IsObject, IsOptional, IsString, Max, Min } from 'class-validator';
-
-export const SEMANTIC_LINK_STATUSES = ['suggested', 'approved', 'rejected', 'dismissed'] as const;
-export const SEMANTIC_LINK_ORIGINS = ['manual', 'semantic', 'llm', 'hybrid', 'rule_based'] as const;
-
-export class ReviewSemanticLinkDto {
-  @IsString()
-  @IsIn(SEMANTIC_LINK_STATUSES)
-  status: (typeof SEMANTIC_LINK_STATUSES)[number];
-}
-
-export class UpsertSemanticLinkDto {
-  @IsString()
-  sourceEntityType: string;
-
-  @IsString()
-  sourceEntityId: string;
-
-  @IsString()
-  targetEntityType: string;
-
-  @IsString()
-  targetEntityId: string;
-
-  @IsOptional()
-  @IsString()
-  linkType?: string;
-
-  @IsOptional()
-  @IsString()
-  @IsIn(SEMANTIC_LINK_STATUSES)
-  status?: (typeof SEMANTIC_LINK_STATUSES)[number];
-
-  @IsOptional()
-  @IsString()
-  @IsIn(SEMANTIC_LINK_ORIGINS)
-  origin?: (typeof SEMANTIC_LINK_ORIGINS)[number];
-
-  @IsOptional()
-  @IsNumber()
-  @Min(0)
-  @Max(1)
-  confidence?: number;
-
-  @IsOptional()
-  @IsString()
-  reason?: string;
-
-  @IsOptional()
-  @IsObject()
-  evidence?: Record<string, any>;
-}

backend/src/knowledge/knowledge.controller.ts

@@ -1,124 +0,0 @@
-import {
-  Body,
-  Controller,
-  Delete,
-  Get,
-  Param,
-  Patch,
-  Post,
-  Query,
-  UseGuards,
-} from '@nestjs/common';
-import { JwtAuthGuard } from '../auth/jwt-auth.guard';
-import { CurrentUser } from '../auth/current-user.decorator';
-import { TenantId } from '../tenant/tenant.decorator';
-import { CreateCommentDto, UpdateCommentDto } from './dto/comment.dto';
-import { ReviewSemanticLinkDto } from './dto/semantic-link.dto';
-import { CommentService } from './services/comment.service';
-import { SemanticOrchestratorService } from './services/semantic-orchestrator.service';
-import { SemanticLinkService } from './services/semantic-link.service';
-import { TenantDatabaseService } from '../tenant/tenant-database.service';
-
-@Controller('knowledge')
-@UseGuards(JwtAuthGuard)
-export class KnowledgeController {
-  constructor(
-    private readonly commentService: CommentService,
-    private readonly semanticOrchestratorService: SemanticOrchestratorService,
-    private readonly semanticLinkService: SemanticLinkService,
-    private readonly tenantDbService: TenantDatabaseService,
-  ) {}
-
-  @Get('comments/:objectApiName/:recordId')
-  async getComments(
-    @TenantId() tenantId: string,
-    @Param('objectApiName') objectApiName: string,
-    @Param('recordId') recordId: string,
-  ) {
-    return this.commentService.listComments(tenantId, objectApiName, recordId);
-  }
-
-  @Post('comments')
-  async createComment(
-    @TenantId() tenantId: string,
-    @Body() dto: CreateCommentDto,
-    @CurrentUser() user: any,
-  ) {
-    return this.commentService.createComment(tenantId, dto, user.userId);
-  }
-
-  @Patch('comments/:id')
-  async updateComment(
-    @TenantId() tenantId: string,
-    @Param('id') id: string,
-    @Body() dto: UpdateCommentDto,
-    @CurrentUser() user: any,
-  ) {
-    return this.commentService.updateComment(tenantId, id, dto, user.userId);
-  }
-
-  @Delete('comments/:id')
-  async deleteComment(
-    @TenantId() tenantId: string,
-    @Param('id') id: string,
-    @CurrentUser() user: any,
-  ) {
-    return this.commentService.deleteComment(tenantId, id, user.userId);
-  }
-
-  @Post('semantic/refresh/:objectApiName/:recordId')
-  async refreshSemantic(
-    @TenantId() tenantId: string,
-    @Param('objectApiName') objectApiName: string,
-    @Param('recordId') recordId: string,
-    @CurrentUser() user: any,
-  ) {
-    return this.semanticOrchestratorService.refreshRecord(
-      tenantId,
-      objectApiName,
-      recordId,
-      user.userId,
-      'manual_refresh',
-    );
-  }
-
-  @Post('semantic/reindex/:objectApiName')
-  async reindexObject(
-    @TenantId() tenantId: string,
-    @Param('objectApiName') objectApiName: string,
-    @CurrentUser() user: any,
-    @Query('limit') limit?: string,
-  ) {
-    const parsedLimit = Number.isFinite(Number(limit)) ? Number(limit) : 250;
-    return this.semanticOrchestratorService.reindexObject(
-      tenantId,
-      objectApiName,
-      user.userId,
-      parsedLimit,
-    );
-  }
-
-  @Get('semantic/links/:objectApiName/:recordId')
-  async listLinks(
-    @TenantId() tenantId: string,
-    @Param('objectApiName') objectApiName: string,
-    @Param('recordId') recordId: string,
-    @Query('status') status?: string,
-  ) {
-    const resolvedTenantId = await this.tenantDbService.resolveTenantId(tenantId);
-    const knex = await this.tenantDbService.getTenantKnexById(resolvedTenantId);
-    return this.semanticLinkService.listForRecord(knex, objectApiName, recordId, status);
-  }
-
-  @Patch('semantic/links/:id/review')
-  async reviewLink(
-    @TenantId() tenantId: string,
-    @Param('id') id: string,
-    @Body() dto: ReviewSemanticLinkDto,
-    @CurrentUser() user: any,
-  ) {
-    const resolvedTenantId = await this.tenantDbService.resolveTenantId(tenantId);
-    const knex = await this.tenantDbService.getTenantKnexById(resolvedTenantId);
-    return this.semanticLinkService.reviewLink(knex, id, dto.status, user.userId);
-  }
-}

backend/src/knowledge/knowledge.module.ts

@@ -1,31 +0,0 @@
-import { Module } from '@nestjs/common';
-import { BullModule } from '@nestjs/bullmq';
-import { KnowledgeController } from './knowledge.controller';
-import { CommentService } from './services/comment.service';
-import { SemanticOrchestratorService } from './services/semantic-orchestrator.service';
-import { SemanticChunkerService } from './services/semantic-chunker.service';
-import { SemanticLinkService } from './services/semantic-link.service';
-import { SemanticRefreshQueueService } from './services/semantic-refresh-queue.service';
-import { SemanticRefreshProcessor } from './semantic-refresh.processor';
-import { TenantModule } from '../tenant/tenant.module';
-import { MeilisearchModule } from '../search/meilisearch.module';
-import { SEMANTIC_REFRESH_QUEUE } from './semantic-refresh.constants';
-
-@Module({
-  imports: [
-    TenantModule,
-    MeilisearchModule,
-    BullModule.registerQueue({ name: SEMANTIC_REFRESH_QUEUE }),
-  ],
-  controllers: [KnowledgeController],
-  providers: [
-    CommentService,
-    SemanticOrchestratorService,
-    SemanticChunkerService,
-    SemanticLinkService,
-    SemanticRefreshQueueService,
-    SemanticRefreshProcessor,
-  ],
-  exports: [SemanticOrchestratorService, SemanticRefreshQueueService],
-})
-export class KnowledgeModule {}

backend/src/knowledge/semantic-refresh.constants.ts

@@ -1,3 +0,0 @@
-export const SEMANTIC_REFRESH_QUEUE = 'semantic-refresh';
-
-export const SEMANTIC_REFRESH_JOB = 'refresh-record';

backend/src/knowledge/semantic-refresh.processor.ts

@@ -1,45 +0,0 @@
-import { Processor, WorkerHost } from '@nestjs/bullmq';
-import { Logger } from '@nestjs/common';
-import { Job } from 'bullmq';
-import { SemanticOrchestratorService } from './services/semantic-orchestrator.service';
-import { SEMANTIC_REFRESH_QUEUE } from './semantic-refresh.constants';
-
-export type SemanticRefreshJobData = {
-  tenantId: string;
-  objectApiName: string;
-  recordId: string;
-  userId?: string;
-  trigger: string;
-};
-
-@Processor(SEMANTIC_REFRESH_QUEUE)
-export class SemanticRefreshProcessor extends WorkerHost {
-  private readonly logger = new Logger(SemanticRefreshProcessor.name);
-
-  constructor(
-    private readonly semanticOrchestratorService: SemanticOrchestratorService,
-  ) {
-    super();
-  }
-
-  async process(job: Job<SemanticRefreshJobData>): Promise<void> {
-    const { tenantId, objectApiName, recordId, userId, trigger } = job.data;
-    this.logger.log(
-      `Processing semantic refresh: ${objectApiName}:${recordId} trigger=${trigger}`,
-    );
-    try {
-      await this.semanticOrchestratorService.refreshRecord(
-        tenantId,
-        objectApiName,
-        recordId,
-        userId,
-        trigger,
-      );
-    } catch (error) {
-      this.logger.error(
-        `Semantic refresh failed: ${objectApiName}:${recordId} trigger=${trigger} error=${error.message}`,
-      );
-      throw error; // Let BullMQ handle retries
-    }
-  }
-}

backend/src/knowledge/services/comment.service.ts

@@ -1,115 +0,0 @@
-import { ForbiddenException, Injectable, NotFoundException } from '@nestjs/common';
-import { TenantDatabaseService } from '../../tenant/tenant-database.service';
-import { CreateCommentDto, UpdateCommentDto } from '../dto/comment.dto';
-import { SemanticRefreshQueueService } from './semantic-refresh-queue.service';
-
-@Injectable()
-export class CommentService {
-  constructor(
-    private readonly tenantDbService: TenantDatabaseService,
-    private readonly semanticRefreshQueue: SemanticRefreshQueueService,
-  ) {}
-
-  async listComments(tenantId: string, parentObjectApiName: string, parentRecordId: string) {
-    const knex = await this.getKnex(tenantId);
-    return knex('comments')
-      .where({
-        parent_object_api_name: parentObjectApiName,
-        parent_record_id: parentRecordId,
-      })
-      .orderBy('created_at', 'desc');
-  }
-
-  async createComment(tenantId: string, dto: CreateCommentDto, userId: string) {
-    const knex = await this.getKnex(tenantId);
-    const [created] = await knex('comments')
-      .insert({
-        parent_object_api_name: dto.parentObjectApiName,
-        parent_record_id: dto.parentRecordId,
-        author_user_id: userId,
-        content: dto.content,
-        created_at: knex.fn.now(),
-        updated_at: knex.fn.now(),
-      })
-      .returning('*');
-
-    console.log(
-      `[Knowledge] Comment created: ${dto.parentObjectApiName}:${dto.parentRecordId} by ${userId}`,
-    );
-    await this.semanticRefreshQueue.enqueue(
-      tenantId,
-      dto.parentObjectApiName,
-      dto.parentRecordId,
-      userId,
-      'comment_created',
-    );
-
-    return created;
-  }
-
-  async updateComment(tenantId: string, commentId: string, dto: UpdateCommentDto, userId: string) {
-    const knex = await this.getKnex(tenantId);
-    const existing = await knex('comments').where({ id: commentId }).first();
-
-    if (!existing) {
-      throw new NotFoundException('Comment not found');
-    }
-
-    if (existing.author_user_id !== userId) {
-      throw new ForbiddenException('Only the author can edit this comment');
-    }
-
-    await knex('comments')
-      .where({ id: commentId })
-      .update({
-        ...(dto.content ? { content: dto.content } : {}),
-        updated_at: knex.fn.now(),
-      });
-
-    console.log(
-      `[Knowledge] Comment updated: ${existing.parent_object_api_name}:${existing.parent_record_id} by ${userId}`,
-    );
-    await this.semanticRefreshQueue.enqueue(
-      tenantId,
-      existing.parent_object_api_name,
-      existing.parent_record_id,
-      userId,
-      'comment_updated',
-    );
-
-    return knex('comments').where({ id: commentId }).first();
-  }
-
-  async deleteComment(tenantId: string, commentId: string, userId: string) {
-    const knex = await this.getKnex(tenantId);
-    const existing = await knex('comments').where({ id: commentId }).first();
-
-    if (!existing) {
-      throw new NotFoundException('Comment not found');
-    }
-
-    if (existing.author_user_id !== userId) {
-      throw new ForbiddenException('Only the author can delete this comment');
-    }
-
-    await knex('comments').where({ id: commentId }).delete();
-
-    console.log(
-      `[Knowledge] Comment deleted: ${existing.parent_object_api_name}:${existing.parent_record_id} by ${userId}`,
-    );
-    await this.semanticRefreshQueue.enqueue(
-      tenantId,
-      existing.parent_object_api_name,
-      existing.parent_record_id,
-      userId,
-      'comment_deleted',
-    );
-
-    return { success: true };
-  }
-
-  private async getKnex(tenantId: string) {
-    const resolvedTenantId = await this.tenantDbService.resolveTenantId(tenantId);
-    return this.tenantDbService.getTenantKnexById(resolvedTenantId);
-  }
-}

backend/src/knowledge/services/semantic-chunker.service.spec.ts

@@ -1,20 +0,0 @@
-import { SemanticChunkerService } from './semantic-chunker.service';
-
-describe('SemanticChunkerService', () => {
-  let service: SemanticChunkerService;
-
-  beforeEach(() => {
-    service = new SemanticChunkerService();
-  });
-
-  it('creates chunks from base narrative and comments', () => {
-    const chunks = service.chunkText('Intro paragraph\n\nSecond paragraph', [
-      { id: 'c-1', content: 'Comment body' },
-    ]);
-
-    expect(chunks).toHaveLength(3);
-    expect(chunks[0].sourceKind).toBe('base_record');
-    expect(chunks[2].sourceKind).toBe('comment');
-    expect(chunks[2].sourceRefId).toBe('c-1');
-  });
-});

backend/src/knowledge/services/semantic-chunker.service.ts

@@ -1,71 +0,0 @@
-import { Injectable } from '@nestjs/common';
-
-export type SemanticChunk = {
-  chunkIndex: number;
-  sourceKind: 'base_record' | 'comment' | 'mixed';
-  sourceRefId: string | null;
-  text: string;
-  metadata: Record<string, any>;
-};
-
-@Injectable()
-export class SemanticChunkerService {
-  chunkText(
-    baseNarrative: string,
-    comments: Array<{ id: string; content: string }>,
-  ): SemanticChunk[] {
-    const chunks: SemanticChunk[] = [];
-
-    const baseParts = this.splitText(baseNarrative);
-    for (const [index, text] of baseParts.entries()) {
-      chunks.push({
-        chunkIndex: chunks.length,
-        sourceKind: 'base_record',
-        sourceRefId: null,
-        text,
-        metadata: { section: 'base', localIndex: index },
-      });
-    }
-
-    for (const comment of comments || []) {
-      const commentParts = this.splitText(comment.content);
-      for (const [index, text] of commentParts.entries()) {
-        chunks.push({
-          chunkIndex: chunks.length,
-          sourceKind: 'comment',
-          sourceRefId: comment.id,
-          text,
-          metadata: { section: 'comment', localIndex: index, commentId: comment.id },
-        });
-      }
-    }
-
-    return chunks;
-  }
-
-  private splitText(text: string): string[] {
-    const normalized = (text || '').trim();
-    if (!normalized) return [];
-
-    const paragraphs = normalized
-      .split(/\n{2,}/)
-      .map((part) => part.trim())
-      .filter(Boolean);
-
-    const chunks: string[] = [];
-    for (const paragraph of paragraphs) {
-      if (paragraph.length <= 500) {
-        chunks.push(paragraph);
-        continue;
-      }
-
-      let cursor = 0;
-      while (cursor < paragraph.length) {
-        chunks.push(paragraph.slice(cursor, cursor + 500).trim());
-        cursor += 500;
-      }
-    }
-
-    return chunks.filter(Boolean);
-  }
-}

backend/src/knowledge/services/semantic-link.service.spec.ts

@@ -1,20 +0,0 @@
-import { SemanticLinkService } from './semantic-link.service';
-
-describe('SemanticLinkService', () => {
-  let service: SemanticLinkService;
-
-  beforeEach(() => {
-    service = new SemanticLinkService();
-  });
-
-  it('normalizes undirected pairs in deterministic order', () => {
-    const normalized = service.normalizeUndirectedPair('Contact', 'b-id', 'Account', 'a-id');
-
-    expect(normalized).toEqual({
-      sourceEntityType: 'Account',
-      sourceEntityId: 'a-id',
-      targetEntityType: 'Contact',
-      targetEntityId: 'b-id',
-    });
-  });
-});

backend/src/knowledge/services/semantic-link.service.ts

@@ -1,186 +0,0 @@
-import { Injectable, NotFoundException } from '@nestjs/common';
-
-export type SemanticLinkUpsertInput = {
-  sourceEntityType: string;
-  sourceEntityId: string;
-  targetEntityType: string;
-  targetEntityId: string;
-  linkType?: string;
-  status?: string;
-  origin?: string;
-  confidence?: number;
-  reason?: string;
-  evidence?: Record<string, any>;
-  suggestedByUserId?: string | null;
-};
-
-@Injectable()
-export class SemanticLinkService {
-  normalizeUndirectedPair(
-    sourceEntityType: string,
-    sourceEntityId: string,
-    targetEntityType: string,
-    targetEntityId: string,
-  ) {
-    const sourceKey = `${sourceEntityType}:${sourceEntityId}`;
-    const targetKey = `${targetEntityType}:${targetEntityId}`;
-
-    if (sourceKey <= targetKey) {
-      return {
-        sourceEntityType,
-        sourceEntityId,
-        targetEntityType,
-        targetEntityId,
-      };
-    }
-
-    return {
-      sourceEntityType: targetEntityType,
-      sourceEntityId: targetEntityId,
-      targetEntityType: sourceEntityType,
-      targetEntityId: sourceEntityId,
-    };
-  }
-
-  async upsertSuggestedLink(knex: any, input: SemanticLinkUpsertInput) {
-    const normalized = this.normalizeUndirectedPair(
-      input.sourceEntityType,
-      input.sourceEntityId,
-      input.targetEntityType,
-      input.targetEntityId,
-    );
-
-    const payload = {
-      source_entity_type: normalized.sourceEntityType,
-      source_entity_id: normalized.sourceEntityId,
-      target_entity_type: normalized.targetEntityType,
-      target_entity_id: normalized.targetEntityId,
-      link_type: input.linkType || 'related_to',
-      status: input.status || 'suggested',
-      origin: input.origin || 'semantic',
-      confidence: input.confidence ?? 0,
-      reason: input.reason || null,
-      evidence: input.evidence ? JSON.stringify(input.evidence) : null,
-      suggested_by_user_id: input.suggestedByUserId || null,
-      updated_at: knex.fn.now(),
-      created_at: knex.fn.now(),
-    };
-
-    await knex('semantic_links')
-      .insert(payload)
-      .onConflict([
-        'source_entity_type',
-        'source_entity_id',
-        'target_entity_type',
-        'target_entity_id',
-        'link_type',
-      ])
-      .merge({
-        status: knex.raw("IF(status = 'approved', status, VALUES(status))"),
-        origin: payload.origin,
-        confidence: knex.raw('GREATEST(confidence, VALUES(confidence))'),
-        reason: payload.reason,
-        evidence: payload.evidence,
-        updated_at: knex.fn.now(),
-      });
-  }
-
-  async listForRecord(knex: any, entityType: string, entityId: string, status?: string) {
-    const query = knex('semantic_links')
-      .where((builder: any) => {
-        builder
-          .where({ source_entity_type: entityType, source_entity_id: entityId })
-          .orWhere({ target_entity_type: entityType, target_entity_id: entityId });
-      })
-      .orderBy('updated_at', 'desc');
-
-    if (status) {
-      query.andWhere({ status });
-    }
-
-    const links = await query;
-    if (!links.length) return links;
-
-    const typeSet = new Set<string>();
-    for (const link of links) {
-      typeSet.add(link.source_entity_type);
-      typeSet.add(link.target_entity_type);
-    }
-
-    const definitions = await knex('object_definitions')
-      .whereIn('apiName', Array.from(typeSet))
-      .select('apiName', 'label', 'pluralLabel', 'tableName', 'fields');
-    const definitionByType = new Map<string, any>(
-      definitions.map((item: any) => [item.apiName, item]),
-    );
-
-    const displayNameCache = new Map<string, string>();
-    const getDisplayField = (definition: any) => {
-      let fields = [];
-      if (Array.isArray(definition?.fields)) {
-        fields = definition.fields;
-      } else if (typeof definition?.fields === 'string') {
-        try {
-          fields = JSON.parse(definition.fields);
-        } catch {
-          fields = [];
-        }
-      }
-      if (fields.some((field: any) => field?.apiName === 'name')) return 'name';
-      const textField = fields.find((field: any) =>
-        ['STRING', 'TEXT', 'EMAIL'].includes(String(field?.type || '').toUpperCase()),
-      );
-      return textField?.apiName || 'id';
-    };
-
-    const resolveTableName = (definition: any) => {
-      if (definition?.tableName) return definition.tableName;
-      if (definition?.pluralLabel) {
-        return String(definition.pluralLabel).toLowerCase().replace(/[^a-z0-9]+/g, '_');
-      }
-      return `${String(definition?.apiName || '').toLowerCase()}s`;
-    };
-
-    const loadDisplayName = async (type: string, id: string) => {
-      const cacheKey = `${type}:${id}`;
-      if (displayNameCache.has(cacheKey)) return displayNameCache.get(cacheKey);
-      const definition = definitionByType.get(type);
-      if (!definition) {
-        displayNameCache.set(cacheKey, id);
-        return id;
-      }
-      const tableName = resolveTableName(definition);
-      const displayField = getDisplayField(definition);
-      const record = await knex(tableName).where({ id }).first();
-      const display = record?.[displayField] ? String(record[displayField]) : id;
-      displayNameCache.set(cacheKey, display);
-      return display;
-    };
-
-    for (const link of links) {
-      link.source_entity_label = definitionByType.get(link.source_entity_type)?.label || link.source_entity_type;
-      link.target_entity_label = definitionByType.get(link.target_entity_type)?.label || link.target_entity_type;
-      link.source_entity_name = await loadDisplayName(link.source_entity_type, link.source_entity_id);
-      link.target_entity_name = await loadDisplayName(link.target_entity_type, link.target_entity_id);
-    }
-
-    return links;
-  }
-
-  async reviewLink(knex: any, linkId: string, status: string, reviewerUserId: string) {
-    const updated = await knex('semantic_links')
-      .where({ id: linkId })
-      .update({
-        status,
-        reviewed_by_user_id: reviewerUserId,
-        reviewed_at: knex.fn.now(),
-        updated_at: knex.fn.now(),
-      });
-
-    if (!updated) {
-      throw new NotFoundException('Semantic link not found');
-    }
-
-    return knex('semantic_links').where({ id: linkId }).first();
-  }
-}

backend/src/knowledge/services/semantic-orchestrator.service.ts

@@ -1,540 +0,0 @@
-import { Injectable, Logger } from '@nestjs/common';
-import { HumanMessage, SystemMessage } from '@langchain/core/messages';
-import { ChatOpenAI } from '@langchain/openai';
-import { TenantDatabaseService } from '../../tenant/tenant-database.service';
-import { MeilisearchService } from '../../search/meilisearch.service';
-import { getCentralPrisma } from '../../prisma/central-prisma.service';
-import { OpenAIConfig } from '../../voice/interfaces/integration-config.interface';
-import { randomUUID } from 'crypto';
-import {
-  DefaultSemanticProjectionAdapter,
-  SemanticProjectionAdapter,
-} from '../adapters/semantic-projection.adapter';
-import { SemanticChunkerService } from './semantic-chunker.service';
-import { SemanticLinkService } from './semantic-link.service';
-
-@Injectable()
-export class SemanticOrchestratorService {
-  private readonly logger = new Logger(SemanticOrchestratorService.name);
-  private readonly adapters: SemanticProjectionAdapter[] = [new DefaultSemanticProjectionAdapter()];
-  private readonly defaultEmbeddingModel =
-    process.env.OPENAI_EMBEDDING_MODEL || 'text-embedding-3-small';
-  private readonly semanticEmbedderName = 'default';
-  private readonly MIN_CONFIDENCE_BASE = 0.7;
-  private readonly MIN_CONFIDENCE_COMMENT = 0.52;
-  private readonly defaultChatModel = process.env.OPENAI_CHAT_MODEL || 'gpt-4o-mini';
-
-  constructor(
-    private readonly tenantDbService: TenantDatabaseService,
-    private readonly meilisearchService: MeilisearchService,
-    private readonly chunkerService: SemanticChunkerService,
-    private readonly semanticLinkService: SemanticLinkService,
-  ) {}
-
-  async refreshRecord(
-    tenantId: string,
-    objectApiName: string,
-    recordId: string,
-    userId?: string,
-    trigger: string = 'manual',
-  ) {
-    this.logger.log(
-      `Semantic refresh start: ${objectApiName}:${recordId} (trigger=${trigger})`,
-    );
-    const resolvedTenantId = await this.tenantDbService.resolveTenantId(tenantId);
-    const knex = await this.tenantDbService.getTenantKnexById(resolvedTenantId);
-
-    const objectDefinition = await knex('object_definitions').where({ apiName: objectApiName }).first();
-    if (!objectDefinition) {
-      this.logger.warn(`Object definition ${objectApiName} not found. Skipping semantic refresh.`);
-      return { skipped: true };
-    }
-
-    const tableName = this.getTableName(objectDefinition);
-    const record = await knex(tableName).where({ id: recordId }).first();
-    if (!record) {
-      this.logger.warn(`Record not found for semantic refresh: ${objectApiName}:${recordId}`);
-      return { skipped: true };
-    }
-
-    const comments = await knex('comments')
-      .where({
-        parent_object_api_name: objectApiName,
-        parent_record_id: recordId,
-      })
-      .orderBy('created_at', 'asc');
-    this.logger.log(
-      `Semantic refresh source: ${objectApiName}:${recordId} comments=${comments.length}`,
-    );
-
-    const adapter = this.adapters.find((candidate) => candidate.supports(objectApiName))!;
-    const projection = adapter.buildProjection({
-      objectApiName,
-      record,
-      objectDefinition,
-      comments,
-    });
-
-    const documentId = await this.upsertSemanticDocument(knex, projection);
-    const chunks = this.chunkerService.chunkText(projection.embeddingNarrative, comments);
-    this.logger.log(
-      `Semantic refresh chunking: ${objectApiName}:${recordId} chunks=${chunks.length}`,
-    );
-    await this.replaceChunks(knex, documentId, chunks);
-
-    const openAiConfig = await this.getOpenAiConfig(resolvedTenantId);
-    const embedderReady = await this.indexChunks(resolvedTenantId, projection, chunks, openAiConfig);
-    await this.generateSuggestions(
-      resolvedTenantId,
-      projection,
-      chunks,
-      openAiConfig,
-      embedderReady,
-      userId,
-      trigger,
-    );
-
-    this.logger.log(
-      `Semantic refresh complete: ${objectApiName}:${recordId} document=${documentId}`,
-    );
-    return { documentId, chunkCount: chunks.length };
-  }
-
-  async reindexObject(tenantId: string, objectApiName: string, userId?: string, limit = 250) {
-    const resolvedTenantId = await this.tenantDbService.resolveTenantId(tenantId);
-    const knex = await this.tenantDbService.getTenantKnexById(resolvedTenantId);
-    const objectDefinition = await knex('object_definitions').where({ apiName: objectApiName }).first();
-    if (!objectDefinition) {
-      return { total: 0, processed: 0 };
-    }
-
-    const tableName = this.getTableName(objectDefinition);
-    const records = await knex(tableName).select('id').limit(limit);
-
-    let processed = 0;
-    for (const record of records) {
-      await this.refreshRecord(resolvedTenantId, objectApiName, record.id, userId, 'batch_reindex');
-      processed += 1;
-    }
-
-    return { total: records.length, processed };
-  }
-
-  private async upsertSemanticDocument(knex: any, projection: any): Promise<string> {
-    const existing = await knex('semantic_documents')
-      .where({ entity_type: projection.entityType, entity_id: projection.entityId })
-      .first();
-
-    if (existing) {
-      await knex('semantic_documents')
-        .where({ id: existing.id })
-        .update({
-          title: projection.title,
-          narrative: projection.narrative,
-          metadata: JSON.stringify(projection.metadata || {}),
-          source_summary: JSON.stringify(projection.sourceSummary || {}),
-          updated_at: knex.fn.now(),
-        });
-      return existing.id;
-    }
-
-    const newId = randomUUID();
-    const [created] = await knex('semantic_documents')
-      .insert({
-        id: newId,
-        entity_type: projection.entityType,
-        entity_id: projection.entityId,
-        title: projection.title,
-        narrative: projection.narrative,
-        metadata: JSON.stringify(projection.metadata || {}),
-        source_summary: JSON.stringify(projection.sourceSummary || {}),
-        created_at: knex.fn.now(),
-        updated_at: knex.fn.now(),
-      })
-      .returning('id');
-
-    if (created && typeof created === 'object' && created.id) {
-      return created.id;
-    }
-    // MySQL may return a numeric insert id (often 0 for UUID PKs). Always trust the generated UUID.
-    return newId;
-  }
-
-  private async replaceChunks(knex: any, documentId: string, chunks: any[]) {
-    if (!documentId) {
-      this.logger.warn('Skipping chunk replace: missing semantic document id.');
-      return;
-    }
-    await knex('semantic_chunks').where({ semantic_document_id: documentId }).delete();
-    if (!chunks.length) return;
-
-    await knex('semantic_chunks').insert(
-      chunks.map((chunk) => ({
-        semantic_document_id: documentId,
-        chunk_index: chunk.chunkIndex,
-        source_kind: chunk.sourceKind,
-        source_ref_id: chunk.sourceRefId,
-        text: chunk.text,
-        metadata: JSON.stringify(chunk.metadata || {}),
-        created_at: knex.fn.now(),
-        updated_at: knex.fn.now(),
-      })),
-    );
-  }
-
-  private async indexChunks(
-    tenantId: string,
-    projection: any,
-    chunks: any[],
-    openAiConfig: OpenAIConfig | null,
-  ) {
-    if (!this.meilisearchService.isEnabled()) {
-      this.logger.warn('Meilisearch disabled; skipping semantic chunk indexing.');
-      return false;
-    }
-
-    const indexName = this.meilisearchService.buildSemanticChunkIndexName(tenantId);
-    let embedderReady = false;
-    if (openAiConfig?.apiKey) {
-      embedderReady = await this.meilisearchService.ensureOpenAiEmbedder(indexName, {
-        embedderName: this.semanticEmbedderName,
-        apiKey: openAiConfig.apiKey,
-        model: openAiConfig.embeddingModel || this.defaultEmbeddingModel,
-        documentTemplate: '{{doc.title}}\n{{doc.text}}',
-      });
-      this.logger.log(
-        `Meilisearch embedder ensured: index=${indexName} model=${openAiConfig.embeddingModel || this.defaultEmbeddingModel}`,
-      );
-    } else {
-      this.logger.warn('OpenAI embedder not configured; semantic search will be lexical only.');
-    }
-    this.logger.log(`Indexing semantic chunks: index=${indexName} count=${chunks.length}`);
-    await this.meilisearchService.upsertDocuments(indexName, chunks.map((chunk) => ({
-      id: `${projection.entityType}_${projection.entityId}_${chunk.chunkIndex}`,
-      entityType: projection.entityType,
-      entityId: projection.entityId,
-      title: projection.title,
-      sourceKind: chunk.sourceKind,
-      sourceRefId: chunk.sourceRefId,
-      text: chunk.text,
-    })));
-    return embedderReady;
-  }
-
-  private async generateSuggestions(
-    tenantId: string,
-    projection: any,
-    chunks: any[],
-    openAiConfig: OpenAIConfig | null,
-    embedderReady: boolean,
-    userId?: string,
-    trigger: string = 'semantic_refresh',
-  ) {
-    if (!this.meilisearchService.isEnabled() || !chunks.length) {
-      this.logger.warn(
-        `Skipping suggestion generation: meili=${this.meilisearchService.isEnabled()} chunks=${chunks.length}`,
-      );
-      return;
-    }
-
-    const indexName = this.meilisearchService.buildSemanticChunkIndexName(tenantId);
-    // Build query from all chunks (base record + comments), prioritising comments
-    // since they carry the most distinctive semantic signal.
-    const commentChunks = chunks.filter((c) => c.sourceKind === 'comment');
-    const baseChunks = chunks.filter((c) => c.sourceKind !== 'comment');
-    const orderedChunks = [...commentChunks, ...baseChunks];
-    const queryText = orderedChunks.map((chunk) => chunk.text).join(' ').slice(0, 1200);
-    this.logger.log(
-      `Generating suggestions: index=${indexName} queryLen=${queryText.length} hybrid=${embedderReady}`,
-    );
-    const search = await this.meilisearchService.searchIndex(
-      indexName,
-      queryText,
-      20,
-      // semanticRatio:1.0 = pure vector search, no lexical component that would
-      // match on shared tokens like 'name:' or 'Comment 1:' across all records.
-      embedderReady ? { embedder: this.semanticEmbedderName, semanticRatio: 1.0 } : undefined,
-    );
-    this.logger.log(
-      `Meilisearch results: index=${indexName} hits=${search.hits?.length || 0} total=${search.total}`,
-    );
-
-    const candidates = new Map<string, { hit: any; confidence: number; rankingDetails?: any }>();
-    for (const hit of search.hits || []) {
-      // Skip self
-      if (hit.entityId === projection.entityId) continue;
-
-      const confidence = hit._semanticScore ?? hit._rankingScore ?? 0;
-      // Use a lower threshold for comment chunks (short, conversational text
-      // naturally produces lower cosine similarity than structured field values).
-      const isComment = hit.sourceKind === 'comment';
-      const threshold = isComment ? this.MIN_CONFIDENCE_COMMENT : this.MIN_CONFIDENCE_BASE;
-      this.logger.log(
-        `Suggestion candidate: ${hit.entityType}:${hit.entityId} confidence=${confidence.toFixed(4)} kind=${hit.sourceKind || 'base'} threshold=${threshold} text="${String(hit.text || '').substring(0, 60)}"`,
-      );
-
-      if (confidence < threshold) {
-        this.logger.log(
-          `Skipping low-confidence match: ${hit.entityType}:${hit.entityId} confidence=${confidence.toFixed(4)} < ${threshold} (${isComment ? 'comment' : 'base'})`,
-        );
-        continue;
-      }
-
-      const key = `${hit.entityType}:${hit.entityId}`;
-      const existing = candidates.get(key);
-      if (!existing || confidence > existing.confidence) {
-        candidates.set(key, {
-          hit,
-          confidence,
-          rankingDetails: hit._rankingScoreDetails || null,
-        });
-      }
-    }
-
-    this.logger.log(`Filtered suggestions: ${candidates.size} passed thresholds (base=${this.MIN_CONFIDENCE_BASE}, comment=${this.MIN_CONFIDENCE_COMMENT})`);
-
-    const resolvedTenantId = await this.tenantDbService.resolveTenantId(tenantId);
-    const knex = await this.tenantDbService.getTenantKnexById(resolvedTenantId);
-
-    for (const [key, { hit, confidence, rankingDetails }] of candidates.entries()) {
-      const [targetType, targetId] = key.split(':');
-      const llmAssessment = await this.assessLinkWithLlm(
-        openAiConfig,
-        trigger,
-        projection,
-        chunks,
-        hit,
-        confidence,
-        rankingDetails,
-      );
-      const reason =
-        llmAssessment?.reason ||
-        this.humanizeTrigger(trigger) ||
-        'Suggested from semantic similarity.';
-      await this.semanticLinkService.upsertSuggestedLink(knex, {
-        sourceEntityType: projection.entityType,
-        sourceEntityId: projection.entityId,
-        targetEntityType: targetType,
-        targetEntityId: targetId,
-        linkType: llmAssessment?.linkType || 'related',
-        status: 'suggested',
-        origin: 'semantic',
-        confidence,
-        reason,
-        evidence: this.buildEvidencePayload(
-          trigger,
-          chunks,
-          hit,
-          confidence,
-          rankingDetails,
-          llmAssessment,
-        ),
-        suggestedByUserId: userId || null,
-      });
-    }
-  }
-
-  private buildEvidencePayload(
-    trigger: string,
-    chunks: any[],
-    hit: any,
-    confidence: number,
-    rankingDetails: any,
-    llmAssessment?: {
-      reason?: string;
-      explanation?: string;
-      matchedSignals?: string[];
-    } | null,
-  ) {
-    return {
-      trigger,
-      explanation:
-        llmAssessment?.explanation ||
-        llmAssessment?.reason ||
-        'Suggested using semantic similarity and ranked chunk evidence.',
-      sourceSignals: chunks.slice(0, 2).map((chunk) => ({
-        sourceKind: chunk.sourceKind,
-        text: chunk.text.slice(0, 220),
-      })),
-      matchedSignals: llmAssessment?.matchedSignals || [],
-      matchedChunks: [
-        {
-          sourceKind: hit.sourceKind,
-          text: String(hit.text || '').slice(0, 220),
-          score: confidence,
-          rankingDetails: rankingDetails || null,
-        },
-      ],
-    };
-  }
-
-  private async assessLinkWithLlm(
-    openAiConfig: OpenAIConfig | null,
-    trigger: string,
-    projection: any,
-    chunks: any[],
-    hit: any,
-    confidence: number,
-    rankingDetails: any,
-  ): Promise<{ linkType: string; reason?: string; explanation?: string; matchedSignals?: string[] } | null> {
-    if (!openAiConfig?.apiKey) {
-      return null;
-    }
-
-    const promptPayload = {
-      trigger,
-      source: {
-        entityType: projection.entityType,
-        title: projection.title,
-        narrative: String(projection.narrative || '').slice(0, 900),
-        keySignals: chunks.slice(0, 3).map((chunk) => ({
-          sourceKind: chunk.sourceKind,
-          text: String(chunk.text || '').slice(0, 220),
-        })),
-      },
-      target: {
-        entityType: hit.entityType,
-        title: hit.title,
-        sourceKind: hit.sourceKind,
-        text: String(hit.text || '').slice(0, 300),
-      },
-      confidence,
-      rankingDetails: rankingDetails || {},
-      allowedLinkTypes: [
-        'related',
-        'supports',
-        'contradicts',
-        'expands',
-        'duplicate_of',
-        'references',
-        'depends_on',
-      ],
-    };
-
-    try {
-      const model = new ChatOpenAI({
-        apiKey: openAiConfig.apiKey,
-        model: openAiConfig.model || this.defaultChatModel,
-        temperature: 0.1,
-      });
-
-      const response = await model.invoke([
-        new SystemMessage(
-          'Classify semantic relationship. Return valid JSON only with keys: linkType, reason, explanation, matchedSignals. linkType must be one of related|supports|contradicts|expands|duplicate_of|references|depends_on.',
-        ),
-        new HumanMessage(JSON.stringify(promptPayload)),
-      ]);
-
-      const content = typeof response.content === 'string'
-        ? response.content
-        : Array.isArray(response.content)
-          ? response.content.map((part: any) => (typeof part === 'string' ? part : part?.text || '')).join('')
-          : '';
-      const normalized = this.extractJsonObject(content);
-      if (!normalized) return null;
-
-      const linkType = this.normalizeLinkType(normalized.linkType);
-      return {
-        linkType,
-        reason: typeof normalized.reason === 'string' ? normalized.reason.trim() : undefined,
-        explanation:
-          typeof normalized.explanation === 'string' ? normalized.explanation.trim() : undefined,
-        matchedSignals: Array.isArray(normalized.matchedSignals)
-          ? normalized.matchedSignals
-            .map((item: any) => String(item || '').trim())
-            .filter(Boolean)
-            .slice(0, 3)
-          : undefined,
-      };
-    } catch (error) {
-      this.logger.warn(`Semantic LLM assessment failed: ${error.message}`);
-      return null;
-    }
-  }
-
-  private extractJsonObject(raw: string): Record<string, any> | null {
-    if (!raw) return null;
-    const trimmed = raw.trim();
-    try {
-      return JSON.parse(trimmed);
-    } catch {
-      const match = trimmed.match(/\{[\s\S]*\}/);
-      if (!match) return null;
-      try {
-        return JSON.parse(match[0]);
-      } catch {
-        return null;
-      }
-    }
-  }
-
-  private normalizeLinkType(value: any): string {
-    const supported = new Set([
-      'related',
-      'supports',
-      'contradicts',
-      'expands',
-      'duplicate_of',
-      'references',
-      'depends_on',
-    ]);
-    const normalized = String(value || '').trim().toLowerCase();
-    if (supported.has(normalized)) return normalized;
-    return 'related';
-  }
-
-  private humanizeTrigger(trigger: string): string {
-    if (!trigger) return 'Suggested from semantic similarity.';
-    const map: Record<string, string> = {
-      comment_created: 'Suggested based on a comment added to the record.',
-      comment_updated: 'Suggested based on a comment update.',
-      manual_refresh: 'Suggested after a manual semantic refresh.',
-      batch_reindex: 'Suggested during semantic reindexing.',
-    };
-    return map[trigger] || 'Suggested from semantic similarity.';
-  }
-
-  private getTableName(objectDefinition: any): string {
-    if (objectDefinition.tableName) return objectDefinition.tableName;
-
-    if (objectDefinition.pluralLabel) {
-      return objectDefinition.pluralLabel.toLowerCase().replace(/[^a-z0-9]+/g, '_');
-    }
-
-    return `${objectDefinition.apiName.toLowerCase()}s`;
-  }
-
-  private async getOpenAiConfig(tenantId: string): Promise<OpenAIConfig | null> {
-    const resolvedTenantId = await this.tenantDbService.resolveTenantId(tenantId);
-    const centralPrisma = getCentralPrisma();
-    const tenant = await centralPrisma.tenant.findUnique({
-      where: { id: resolvedTenantId },
-      select: { integrationsConfig: true },
-    });
-
-    let config = tenant?.integrationsConfig
-      ? typeof tenant.integrationsConfig === 'string'
-        ? this.tenantDbService.decryptIntegrationsConfig(tenant.integrationsConfig)
-        : tenant.integrationsConfig
-      : null;
-
-    if (!config?.openai && process.env.OPENAI_API_KEY) {
-      config = {
-        ...(config || {}),
-        openai: {
-          apiKey: process.env.OPENAI_API_KEY,
-          embeddingModel: this.defaultEmbeddingModel,
-        },
-      };
-    }
-
-    if (config?.openai?.apiKey) {
-      return {
-        apiKey: config.openai.apiKey,
-        embeddingModel: config.openai.embeddingModel || this.defaultEmbeddingModel,
-      };
-    }
-
-    return null;
-  }
-}

backend/src/knowledge/services/semantic-refresh-queue.service.ts

@@ -1,42 +0,0 @@
-import { Injectable, Logger } from '@nestjs/common';
-import { InjectQueue } from '@nestjs/bullmq';
-import { Queue } from 'bullmq';
-import {
-  SEMANTIC_REFRESH_QUEUE,
-  SEMANTIC_REFRESH_JOB,
-} from '../semantic-refresh.constants';
-import { SemanticRefreshJobData } from '../semantic-refresh.processor';
-
-@Injectable()
-export class SemanticRefreshQueueService {
-  private readonly logger = new Logger(SemanticRefreshQueueService.name);
-
-  constructor(
-    @InjectQueue(SEMANTIC_REFRESH_QUEUE) private readonly queue: Queue,
-  ) {}
-
-  async enqueue(
-    tenantId: string,
-    objectApiName: string,
-    recordId: string,
-    userId?: string,
-    trigger: string = 'manual',
-  ): Promise<void> {
-    const data: SemanticRefreshJobData = {
-      tenantId,
-      objectApiName,
-      recordId,
-      userId,
-      trigger,
-    };
-    await this.queue.add(SEMANTIC_REFRESH_JOB, data, {
-      attempts: 3,
-      backoff: { type: 'exponential', delay: 2000 },
-      removeOnComplete: 100,
-      removeOnFail: 50,
-    });
-    this.logger.debug(
-      `Enqueued semantic refresh: ${objectApiName}:${recordId} trigger=${trigger}`,
-    );
-  }
-}

backend/src/models/user.model.ts

@@ -1,5 +1,4 @@
 import { BaseModel } from './base.model';
-import { ModelOptions, QueryContext } from 'objection';
 
 export class User extends BaseModel {
   static tableName = 'users';
@@ -9,8 +8,6 @@ export class User extends BaseModel {
   password: string;
   firstName?: string;
   lastName?: string;
-  alias?: string;
-  name?: string;
   isActive: boolean;
   createdAt: Date;
   updatedAt: Date;
@@ -25,37 +22,11 @@ export class User extends BaseModel {
         password: { type: 'string' },
         firstName: { type: 'string' },
         lastName: { type: 'string' },
-        alias: { type: 'string' },
-        name: { type: 'string' },
         isActive: { type: 'boolean' },
       },
     };
   }
 
-  /**
-   * Compute the `name` column before insert/update so lookup fields
-   * referencing User.name always have a value.
-   */
-  private computeName() {
-    if (this.alias) {
-      this.name = this.alias;
-    } else if (this.firstName || this.lastName) {
-      this.name = [this.firstName, this.lastName].filter(Boolean).join(' ');
-    } else if (this.email) {
-      this.name = this.email;
-    }
-  }
-
-  $beforeInsert(queryContext: QueryContext) {
-    super.$beforeInsert(queryContext);
-    this.computeName();
-  }
-
-  $beforeUpdate(opt: ModelOptions, queryContext: QueryContext) {
-    super.$beforeUpdate(opt, queryContext);
-    this.computeName();
-  }
-
   static get relationMappings() {
     const { UserRole } = require('./user-role.model');
     const { Role } = require('./role.model');

backend/src/object/field-mapper.service.ts

@@ -152,7 +152,6 @@ export class FieldMapperService {
       'phone': 'text',
       'picklist': 'select',
       'multipicklist': 'multiSelect',
-      'multi_picklist': 'multiSelect',
       'lookup': 'belongsTo',
       'master-detail': 'belongsTo',
       'currency': 'currency',

backend/src/object/object.module.ts

@@ -10,10 +10,9 @@ import { RbacModule } from '../rbac/rbac.module';
 import { ModelRegistry } from './models/model.registry';
 import { ModelService } from './models/model.service';
 import { MeilisearchModule } from '../search/meilisearch.module';
-import { KnowledgeModule } from '../knowledge/knowledge.module';
 
 @Module({
-  imports: [TenantModule, MigrationModule, RbacModule, MeilisearchModule, KnowledgeModule],
+  imports: [TenantModule, MigrationModule, RbacModule, MeilisearchModule],
   providers: [
     ObjectService,
     SchemaManagementService,

backend/src/object/object.service.ts

@@ -9,7 +9,6 @@ import { FieldDefinition } from '../models/field-definition.model';
 import { User } from '../models/user.model';
 import { ObjectMetadata } from './models/dynamic-model.factory';
 import { MeilisearchService } from '../search/meilisearch.service';
-import { SemanticRefreshQueueService } from '../knowledge/services/semantic-refresh-queue.service';
 
 type SearchFilter = {
   field: string;
@@ -40,7 +39,6 @@ export class ObjectService {
     private modelService: ModelService,
     private authService: AuthorizationService,
     private meilisearchService: MeilisearchService,
-    private semanticRefreshQueue: SemanticRefreshQueueService,
   ) {}
 
   // Setup endpoints - Object metadata management
@@ -338,27 +336,13 @@ export class ObjectService {
       updated_at: knex.fn.now(),
     };
     
-    // Build UI metadata from all sources
-    const uiMetadataObj: any = {};
-
-    // Merge general uiMetadata (options, placeholder, helpText, etc.)
-    if (data.uiMetadata && typeof data.uiMetadata === 'object') {
-      Object.assign(uiMetadataObj, data.uiMetadata);
-    }
-
-    // Store relation-specific fields in UI metadata if provided
-    if (data.relationDisplayField) {
-      uiMetadataObj.relationDisplayField = data.relationDisplayField;
-    }
-    if (data.relationObjects) {
-      uiMetadataObj.relationObjects = data.relationObjects;
-    }
-    if (data.relationTypeField) {
-      uiMetadataObj.relationTypeField = data.relationTypeField;
-    }
-
-    if (Object.keys(uiMetadataObj).length > 0) {
-      fieldData.ui_metadata = JSON.stringify(uiMetadataObj);
+    // Store relationDisplayField in UI metadata if provided
+    if (data.relationDisplayField || data.relationObjects || data.relationTypeField) {
+      fieldData.ui_metadata = JSON.stringify({
+        relationDisplayField: data.relationDisplayField,
+        relationObjects: data.relationObjects,
+        relationTypeField: data.relationTypeField,
+      });
     }
     
     await knex('field_definitions').insert(fieldData);
@@ -1130,13 +1114,6 @@ export class ObjectService {
     );
     const record = await boundModel.query().insert(normalizedRecordData);
     await this.indexRecord(resolvedTenantId, objectApiName, objectDefModel.fields, record);
-    await this.semanticRefreshQueue.enqueue(
-      resolvedTenantId,
-      objectApiName,
-      record.id,
-      userId,
-      'record_created',
-    );
     return record;
   }
 
@@ -1206,13 +1183,6 @@ export class ObjectService {
     await boundModel.query().patch(normalizedEditableData).where({ id: recordId });
     const record = await boundModel.query().where({ id: recordId }).first();
     await this.indexRecord(resolvedTenantId, objectApiName, objectDefModel.fields, record);
-    await this.semanticRefreshQueue.enqueue(
-      resolvedTenantId,
-      objectApiName,
-      recordId,
-      userId,
-      'record_updated',
-    );
     return record;
   }
 

backend/src/object/runtime-object.controller.ts

@@ -111,33 +111,4 @@ export class RuntimeObjectController {
       user.userId,
     );
   }
-
-  /**
-   * Direct filter-based search — used when applying a saved list view.
-   * Bypasses the AI planning step; accepts pre-resolved structured filters.
-   */
-  @Post(':objectApiName/records/search')
-  async searchRecords(
-    @TenantId() tenantId: string,
-    @Param('objectApiName') objectApiName: string,
-    @CurrentUser() user: any,
-    @Body() body: {
-      filters?: Array<{ field: string; operator: string; value?: any; values?: any[]; from?: string; to?: string }>;
-      sort?: { field: string; direction: 'asc' | 'desc' } | null;
-      page?: number;
-      pageSize?: number;
-    },
-  ) {
-    const page = Number.isFinite(Number(body?.page)) ? Number(body.page) : 1;
-    const pageSize = Number.isFinite(Number(body?.pageSize)) ? Number(body.pageSize) : 25;
-
-    return this.objectService.searchRecordsWithFilters(
-      tenantId,
-      objectApiName,
-      user.userId,
-      body?.filters || [],
-      { page, pageSize },
-      body?.sort || undefined,
-    );
-  }
 }

backend/src/page-layout/page-layout.service.ts

@@ -7,7 +7,7 @@ export class PageLayoutService {
   constructor(private tenantDbService: TenantDatabaseService) {}
 
   async create(tenantId: string, createDto: CreatePageLayoutDto) {
-    const knex = await this.tenantDbService.getTenantKnexById(tenantId);
+    const knex = await this.tenantDbService.getTenantKnex(tenantId);
     const layoutType = createDto.layoutType || 'detail';
     
     // If this layout is set as default, unset other defaults for the same object and layout type
@@ -32,7 +32,7 @@ export class PageLayoutService {
   }
 
   async findAll(tenantId: string, objectId?: string, layoutType?: PageLayoutType) {
-    const knex = await this.tenantDbService.getTenantKnexById(tenantId);
+    const knex = await this.tenantDbService.getTenantKnex(tenantId);
     
     let query = knex('page_layouts');
 
@@ -49,7 +49,7 @@ export class PageLayoutService {
   }
 
   async findOne(tenantId: string, id: string) {
-    const knex = await this.tenantDbService.getTenantKnexById(tenantId);
+    const knex = await this.tenantDbService.getTenantKnex(tenantId);
     
     const layout = await knex('page_layouts').where({ id }).first();
 
@@ -61,7 +61,7 @@ export class PageLayoutService {
   }
 
   async findDefaultByObject(tenantId: string, objectId: string, layoutType: PageLayoutType = 'detail') {
-    const knex = await this.tenantDbService.getTenantKnexById(tenantId);
+    const knex = await this.tenantDbService.getTenantKnex(tenantId);
     
     const layout = await knex('page_layouts')
       .where({ object_id: objectId, is_default: true, layout_type: layoutType })
@@ -71,7 +71,7 @@ export class PageLayoutService {
   }
 
   async update(tenantId: string, id: string, updateDto: UpdatePageLayoutDto) {
-    const knex = await this.tenantDbService.getTenantKnexById(tenantId);
+    const knex = await this.tenantDbService.getTenantKnex(tenantId);
     
     // Check if layout exists
     const layout = await this.findOne(tenantId, id);
@@ -112,7 +112,7 @@ export class PageLayoutService {
   }
 
   async remove(tenantId: string, id: string) {
-    const knex = await this.tenantDbService.getTenantKnexById(tenantId);
+    const knex = await this.tenantDbService.getTenantKnex(tenantId);
     
     await this.findOne(tenantId, id);
 

backend/src/rbac/setup-users.controller.ts

@@ -39,7 +39,7 @@ export class SetupUsersController {
   @Post()
   async createUser(
     @TenantId() tenantId: string,
-    @Body() data: { email: string; password: string; firstName?: string; lastName?: string; alias?: string },
+    @Body() data: { email: string; password: string; firstName?: string; lastName?: string },
   ) {
     const resolvedTenantId = await this.tenantDbService.resolveTenantId(tenantId);
     const knex = await this.tenantDbService.getTenantKnexById(resolvedTenantId);
@@ -52,7 +52,6 @@ export class SetupUsersController {
       password: hashedPassword,
       firstName: data.firstName,
       lastName: data.lastName,
-      alias: data.alias,
       isActive: true,
     });
     
@@ -63,7 +62,7 @@ export class SetupUsersController {
   async updateUser(
     @TenantId() tenantId: string,
     @Param('id') id: string,
-    @Body() data: { email?: string; password?: string; firstName?: string; lastName?: string; alias?: string },
+    @Body() data: { email?: string; password?: string; firstName?: string; lastName?: string },
   ) {
     const resolvedTenantId = await this.tenantDbService.resolveTenantId(tenantId);
     const knex = await this.tenantDbService.getTenantKnexById(resolvedTenantId);
@@ -73,7 +72,6 @@ export class SetupUsersController {
     if (data.email) updateData.email = data.email;
     if (data.firstName !== undefined) updateData.firstName = data.firstName;
     if (data.lastName !== undefined) updateData.lastName = data.lastName;
-    if (data.alias !== undefined) updateData.alias = data.alias;
     
     // Hash password if provided
     if (data.password) {

backend/src/saved-list-view/dto/saved-list-view.dto.ts

@@ -1,53 +0,0 @@
-import { IsString, IsNotEmpty, IsArray, IsOptional } from 'class-validator';
-
-export class CreateSavedViewDto {
-  @IsString()
-  @IsNotEmpty()
-  name: string;
-
-  @IsString()
-  @IsNotEmpty()
-  objectApiName: string;
-
-  @IsArray()
-  filters: Array<{
-    field: string;
-    operator: string;
-    value?: any;
-    values?: any[];
-    from?: string;
-    to?: string;
-  }>;
-
-  @IsOptional()
-  sort?: { field: string; direction: 'asc' | 'desc' } | null;
-
-  @IsOptional()
-  @IsString()
-  description?: string;
-}
-
-export class UpdateSavedViewDto {
-  @IsOptional()
-  @IsString()
-  @IsNotEmpty()
-  name?: string;
-
-  @IsOptional()
-  @IsArray()
-  filters?: Array<{
-    field: string;
-    operator: string;
-    value?: any;
-    values?: any[];
-    from?: string;
-    to?: string;
-  }>;
-
-  @IsOptional()
-  sort?: { field: string; direction: 'asc' | 'desc' } | null;
-
-  @IsOptional()
-  @IsString()
-  description?: string;
-}

backend/src/saved-list-view/saved-list-view.controller.ts

@@ -1,92 +0,0 @@
-import {
-  Controller,
-  Get,
-  Post,
-  Patch,
-  Delete,
-  Body,
-  Param,
-  UseGuards,
-  ForbiddenException,
-  NotFoundException,
-} from '@nestjs/common';
-import { JwtAuthGuard } from '../auth/jwt-auth.guard';
-import { CurrentUser } from '../auth/current-user.decorator';
-import { TenantId } from '../tenant/tenant.decorator';
-import { SavedListViewService } from './saved-list-view.service';
-import { CreateSavedViewDto, UpdateSavedViewDto } from './dto/saved-list-view.dto';
-import { CreateRecordShareDto } from '../rbac/dto/create-record-share.dto';
-
-@Controller('saved-views')
-@UseGuards(JwtAuthGuard)
-export class SavedListViewController {
-  constructor(private readonly savedListViewService: SavedListViewService) {}
-
-  @Get(':objectApiName')
-  findByObject(
-    @TenantId() tenantId: string,
-    @CurrentUser() user: any,
-    @Param('objectApiName') objectApiName: string,
-  ) {
-    return this.savedListViewService.findByObject(tenantId, user.userId, objectApiName);
-  }
-
-  @Post()
-  create(
-    @TenantId() tenantId: string,
-    @CurrentUser() user: any,
-    @Body() dto: CreateSavedViewDto,
-  ) {
-    return this.savedListViewService.create(tenantId, user.userId, dto);
-  }
-
-  @Patch(':id')
-  update(
-    @TenantId() tenantId: string,
-    @CurrentUser() user: any,
-    @Param('id') id: string,
-    @Body() dto: UpdateSavedViewDto,
-  ) {
-    return this.savedListViewService.update(tenantId, user.userId, id, dto);
-  }
-
-  @Delete(':id')
-  remove(
-    @TenantId() tenantId: string,
-    @CurrentUser() user: any,
-    @Param('id') id: string,
-  ) {
-    return this.savedListViewService.remove(tenantId, user.userId, id);
-  }
-
-  // ── Sharing endpoints (reuse record_shares table) ────────────────────────
-
-  @Get(':id/shares')
-  getShares(
-    @TenantId() tenantId: string,
-    @CurrentUser() user: any,
-    @Param('id') id: string,
-  ) {
-    return this.savedListViewService.getShares(tenantId, user.userId, id);
-  }
-
-  @Post(':id/shares')
-  createShare(
-    @TenantId() tenantId: string,
-    @CurrentUser() user: any,
-    @Param('id') id: string,
-    @Body() dto: CreateRecordShareDto,
-  ) {
-    return this.savedListViewService.createShare(tenantId, user.userId, id, dto);
-  }
-
-  @Delete(':id/shares/:shareId')
-  removeShare(
-    @TenantId() tenantId: string,
-    @CurrentUser() user: any,
-    @Param('id') id: string,
-    @Param('shareId') shareId: string,
-  ) {
-    return this.savedListViewService.removeShare(tenantId, user.userId, id, shareId);
-  }
-}

backend/src/saved-list-view/saved-list-view.module.ts

@@ -1,12 +0,0 @@
-import { Module } from '@nestjs/common';
-import { SavedListViewService } from './saved-list-view.service';
-import { SavedListViewController } from './saved-list-view.controller';
-import { TenantModule } from '../tenant/tenant.module';
-
-@Module({
-  imports: [TenantModule],
-  controllers: [SavedListViewController],
-  providers: [SavedListViewService],
-  exports: [SavedListViewService],
-})
-export class SavedListViewModule {}

backend/src/saved-list-view/saved-list-view.service.ts

@@ -1,264 +0,0 @@
-import { Injectable, NotFoundException, ForbiddenException, BadRequestException } from '@nestjs/common';
-import { TenantDatabaseService } from '../tenant/tenant-database.service';
-import { CreateSavedViewDto, UpdateSavedViewDto } from './dto/saved-list-view.dto';
-import { RecordShare } from '../models/record-share.model';
-import { ObjectDefinition } from '../models/object-definition.model';
-
-@Injectable()
-export class SavedListViewService {
-  constructor(private readonly tenantDbService: TenantDatabaseService) {}
-
-  // ── Helpers ──────────────────────────────────────────────────────────────
-
-  /**
-   * Resolves the system object_definition ID for SavedListView.
-   * This is needed to create record_shares rows for saved views.
-   */
-  private async getSavedViewObjectDefId(knex: any): Promise<string> {
-    const objectDef = await ObjectDefinition.query(knex)
-      .findOne({ apiName: 'SavedListView' });
-    if (!objectDef) {
-      throw new BadRequestException(
-        'SavedListView system object not found. Please run migrations.',
-      );
-    }
-    return objectDef.id;
-  }
-
-  // ── CRUD ─────────────────────────────────────────────────────────────────
-
-  /**
-   * Returns all saved views visible to the user for a given object:
-   * - Views owned by the user
-   * - Views shared with the user via record_shares
-   */
-  async findByObject(tenantId: string, userId: string, objectApiName: string) {
-    const resolvedTenantId = await this.tenantDbService.resolveTenantId(tenantId);
-    const knex = await this.tenantDbService.getTenantKnexById(resolvedTenantId);
-
-    const objectDefId = await this.getSavedViewObjectDefId(knex);
-
-    // IDs of views shared with this user via record_shares
-    const sharedViewIds = await RecordShare.query(knex)
-      .where({ objectDefinitionId: objectDefId, granteeUserId: userId })
-      .whereNull('revokedAt')
-      .where(builder => {
-        builder.whereNull('expiresAt').orWhere('expiresAt', '>', new Date());
-      })
-      .select('recordId');
-
-    const sharedIds = sharedViewIds.map((s: any) => s.recordId);
-
-    const rows = await knex('saved_list_views')
-      .where({ object_api_name: objectApiName })
-      .andWhere(function () {
-        this.where({ user_id: userId });
-        if (sharedIds.length > 0) {
-          this.orWhereIn('id', sharedIds);
-        }
-      })
-      .orderBy('created_at', 'asc');
-
-    return rows.map((r: any) => this.deserialize(r, userId));
-  }
-
-  async create(tenantId: string, userId: string, dto: CreateSavedViewDto) {
-    const resolvedTenantId = await this.tenantDbService.resolveTenantId(tenantId);
-    const knex = await this.tenantDbService.getTenantKnexById(resolvedTenantId);
-
-    const id = require('crypto').randomUUID();
-
-    await knex('saved_list_views').insert({
-      id,
-      name: dto.name,
-      object_api_name: dto.objectApiName,
-      user_id: userId,
-      is_shared: false,
-      strategy: 'query',
-      filters: JSON.stringify(dto.filters || []),
-      sort: dto.sort ? JSON.stringify(dto.sort) : null,
-      description: dto.description || null,
-    });
-
-    const row = await knex('saved_list_views').where({ id }).first();
-    return this.deserialize(row, userId);
-  }
-
-  async update(tenantId: string, userId: string, id: string, dto: UpdateSavedViewDto) {
-    const resolvedTenantId = await this.tenantDbService.resolveTenantId(tenantId);
-    const knex = await this.tenantDbService.getTenantKnexById(resolvedTenantId);
-
-    const existing = await knex('saved_list_views').where({ id }).first();
-    if (!existing) throw new NotFoundException(`Saved view ${id} not found`);
-    if (existing.user_id !== userId) {
-      throw new ForbiddenException('You can only modify views you own');
-    }
-
-    const updates: Record<string, any> = { updated_at: knex.fn.now() };
-    if (dto.name !== undefined) updates.name = dto.name;
-    if (dto.filters !== undefined) updates.filters = JSON.stringify(dto.filters);
-    if (dto.sort !== undefined) updates.sort = dto.sort ? JSON.stringify(dto.sort) : null;
-    if (dto.description !== undefined) updates.description = dto.description;
-
-    await knex('saved_list_views').where({ id }).update(updates);
-
-    const row = await knex('saved_list_views').where({ id }).first();
-    return this.deserialize(row, userId);
-  }
-
-  async remove(tenantId: string, userId: string, id: string) {
-    const resolvedTenantId = await this.tenantDbService.resolveTenantId(tenantId);
-    const knex = await this.tenantDbService.getTenantKnexById(resolvedTenantId);
-
-    const existing = await knex('saved_list_views').where({ id }).first();
-    if (!existing) throw new NotFoundException(`Saved view ${id} not found`);
-    if (existing.user_id !== userId) {
-      throw new ForbiddenException('You can only delete views you own');
-    }
-
-    // Also clean up any record_shares for this view
-    const objectDefId = await this.getSavedViewObjectDefId(knex);
-    await RecordShare.query(knex)
-      .where({ objectDefinitionId: objectDefId, recordId: id })
-      .delete();
-
-    await knex('saved_list_views').where({ id }).delete();
-    return { deleted: true };
-  }
-
-  // ── Sharing via record_shares ────────────────────────────────────────────
-
-  async getShares(tenantId: string, userId: string, viewId: string) {
-    const resolvedTenantId = await this.tenantDbService.resolveTenantId(tenantId);
-    const knex = await this.tenantDbService.getTenantKnexById(resolvedTenantId);
-
-    const view = await knex('saved_list_views').where({ id: viewId }).first();
-    if (!view) throw new NotFoundException('Saved view not found');
-    if (view.user_id !== userId) {
-      throw new ForbiddenException('Only the view owner can manage sharing');
-    }
-
-    const objectDefId = await this.getSavedViewObjectDefId(knex);
-
-    const shares = await RecordShare.query(knex)
-      .where({ objectDefinitionId: objectDefId, recordId: viewId })
-      .whereNull('revokedAt')
-      .where(builder => {
-        builder.whereNull('expiresAt').orWhere('expiresAt', '>', new Date());
-      })
-      .withGraphFetched('[granteeUser]')
-      .orderBy('createdAt', 'desc');
-
-    return shares;
-  }
-
-  async createShare(
-    tenantId: string,
-    userId: string,
-    viewId: string,
-    dto: { granteeUserId: string; canRead: boolean; canEdit: boolean; canDelete: boolean; expiresAt?: string },
-  ) {
-    const resolvedTenantId = await this.tenantDbService.resolveTenantId(tenantId);
-    const knex = await this.tenantDbService.getTenantKnexById(resolvedTenantId);
-
-    const view = await knex('saved_list_views').where({ id: viewId }).first();
-    if (!view) throw new NotFoundException('Saved view not found');
-    if (view.user_id !== userId) {
-      throw new ForbiddenException('Only the view owner can share it');
-    }
-    if (dto.granteeUserId === userId) {
-      throw new BadRequestException('Cannot share a view with yourself');
-    }
-
-    const objectDefId = await this.getSavedViewObjectDefId(knex);
-
-    // Upsert: if non-revoked share already exists for this grantee, update it
-    const existing = await RecordShare.query(knex)
-      .where({
-        objectDefinitionId: objectDefId,
-        recordId: viewId,
-        granteeUserId: dto.granteeUserId,
-      })
-      .whereNull('revokedAt')
-      .first();
-
-    if (existing) {
-      await RecordShare.query(knex)
-        .patchAndFetchById(existing.id, {
-          accessLevel: {
-            canRead: dto.canRead,
-            canEdit: dto.canEdit,
-            canDelete: dto.canDelete,
-          },
-          expiresAt: dto.expiresAt
-            ? (knex.raw('?', [new Date(dto.expiresAt).toISOString().slice(0, 19).replace('T', ' ')]) as any)
-            : null,
-        } as any);
-
-      return RecordShare.query(knex)
-        .findById(existing.id)
-        .withGraphFetched('[granteeUser]');
-    }
-
-    const share = await RecordShare.query(knex).insertAndFetch({
-      objectDefinitionId: objectDefId,
-      recordId: viewId,
-      granteeUserId: dto.granteeUserId,
-      grantedByUserId: userId,
-      accessLevel: {
-        canRead: dto.canRead,
-        canEdit: dto.canEdit,
-        canDelete: dto.canDelete,
-      },
-      expiresAt: dto.expiresAt
-        ? (knex.raw('?', [new Date(dto.expiresAt).toISOString().slice(0, 19).replace('T', ' ')]) as any)
-        : null,
-    } as any);
-
-    return RecordShare.query(knex)
-      .findById(share.id)
-      .withGraphFetched('[granteeUser]');
-  }
-
-  async removeShare(tenantId: string, userId: string, viewId: string, shareId: string) {
-    const resolvedTenantId = await this.tenantDbService.resolveTenantId(tenantId);
-    const knex = await this.tenantDbService.getTenantKnexById(resolvedTenantId);
-
-    const view = await knex('saved_list_views').where({ id: viewId }).first();
-    if (!view) throw new NotFoundException('Saved view not found');
-    if (view.user_id !== userId) {
-      throw new ForbiddenException('Only the view owner can manage sharing');
-    }
-
-    const share = await RecordShare.query(knex).findById(shareId);
-    if (!share) throw new NotFoundException('Share not found');
-
-    // Soft-revoke
-    await RecordShare.query(knex)
-      .findById(shareId)
-      .patch({ revokedAt: knex.fn.now() } as any);
-
-    return { revoked: true };
-  }
-
-  // ── Serialisation ────────────────────────────────────────────────────────
-
-  private deserialize(row: any, currentUserId: string) {
-    return {
-      id: row.id,
-      name: row.name,
-      objectApiName: row.object_api_name,
-      userId: row.user_id,
-      isOwner: row.user_id === currentUserId,
-      isShared: Boolean(row.is_shared),
-      strategy: row.strategy,
-      filters: typeof row.filters === 'string' ? JSON.parse(row.filters) : (row.filters ?? []),
-      sort: row.sort
-        ? (typeof row.sort === 'string' ? JSON.parse(row.sort) : row.sort)
-        : null,
-      description: row.description,
-      createdAt: row.created_at,
-      updatedAt: row.updated_at,
-    };
-  }
-}

backend/src/search/meilisearch.service.ts

@@ -8,23 +8,9 @@ type MeiliConfig = {
   indexPrefix: string;
 };
 
-type HybridSearchOptions = {
-  embedder: string;
-  semanticRatio?: number;
-};
-
-type OpenAiEmbedderConfig = {
-  embedderName: string;
-  apiKey: string;
-  model: string;
-  documentTemplate: string;
-};
-
 @Injectable()
 export class MeilisearchService {
   private readonly logger = new Logger(MeilisearchService.name);
-  private readonly embedderCache = new Map<string, string>();
-  private vectorStoreEnabled = false;
 
   isEnabled(): boolean {
     return Boolean(this.getConfig());
@@ -172,100 +158,6 @@ export class MeilisearchService {
     }
   }
 
-  buildSemanticChunkIndexName(tenantId: string): string {
-    const config = this.getConfig();
-    const prefix = config?.indexPrefix || 'tenant_';
-    return `${prefix}${tenantId}_semantic_chunks`.toLowerCase();
-  }
-
-  async upsertDocuments(indexName: string, documents: Record<string, any>[]): Promise<void> {
-    const config = this.getConfig();
-    if (!config || !Array.isArray(documents) || documents.length === 0) return;
-
-    const url = `${config.host}/indexes/${encodeURIComponent(indexName)}/documents?primaryKey=id`;
-    try {
-      const response = await this.requestJson('POST', url, documents, this.buildHeaders(config));
-      if (!this.isSuccessStatus(response.status)) {
-        this.logger.warn(`Meilisearch document upsert failed for index ${indexName}: ${response.status}`);
-        return;
-      }
-      // Meilisearch indexes (and embeds) documents asynchronously. Wait for the task
-      // to complete so callers can immediately search and see the new documents.
-      const taskUid = response.body?.taskUid ?? response.body?.uid;
-      if (Number.isFinite(Number(taskUid))) {
-        const succeeded = await this.waitForTask(config, Number(taskUid), 30000);
-        if (!succeeded) {
-          this.logger.warn(`Meilisearch indexing task did not succeed within timeout: taskUid=${taskUid} index=${indexName}`);
-        }
-      }
-    } catch (error) {
-      this.logger.warn(`Meilisearch document upsert failed: ${error.message}`);
-    }
-  }
-
-  async searchIndex(
-    indexName: string,
-    query: string,
-    limit = 20,
-    hybrid?: HybridSearchOptions,
-  ): Promise<{ hits: any[]; total: number }> {
-    const config = this.getConfig();
-    if (!config) return { hits: [], total: 0 };
-
-    const url = `${config.host}/indexes/${encodeURIComponent(indexName)}/search`;
-    try {
-      const response = await this.requestJson(
-        'POST',
-        url,
-        {
-          q: query,
-          limit,
-          showRankingScore: true,
-          ...(hybrid ? { hybrid, showRankingScoreDetails: true } : {}),
-        },
-        this.buildHeaders(config),
-      );
-
-      if (!this.isSuccessStatus(response.status)) {
-        this.logger.warn(
-          `Meilisearch search failed for index ${indexName}: ${response.status}`,
-        );
-        this.logger.warn(
-          `Meilisearch search payload: ${JSON.stringify({ q: query, limit, hybrid })}`,
-        );
-        this.logger.warn(
-          `Meilisearch search error body: ${JSON.stringify(response.body)}`,
-        );
-        // If hybrid is invalid (embedder missing), retry once without hybrid
-        if (hybrid && response.body?.code === 'invalid_embedder') {
-          const fallback = await this.requestJson(
-            'POST',
-            url,
-            { q: query, limit },
-            this.buildHeaders(config),
-          );
-          if (this.isSuccessStatus(fallback.status)) {
-            const hits = Array.isArray(fallback.body?.hits) ? fallback.body.hits : [];
-            const total =
-              fallback.body?.estimatedTotalHits ?? fallback.body?.nbHits ?? hits.length;
-            this.logger.warn(
-              `Meilisearch hybrid failed; fell back to lexical search for index ${indexName}.`,
-            );
-            return { hits, total };
-          }
-        }
-        return { hits: [], total: 0 };
-      }
-
-      const hits = Array.isArray(response.body?.hits) ? response.body.hits : [];
-      const total = response.body?.estimatedTotalHits ?? response.body?.nbHits ?? hits.length;
-      return { hits, total };
-    } catch (error) {
-      this.logger.warn(`Meilisearch search failed: ${error.message}`);
-      return { hits: [], total: 0 };
-    }
-  }
-
   private getConfig(): MeiliConfig | null {
     const host = process.env.MEILI_HOST || process.env.MEILISEARCH_HOST;
     if (!host) return null;
@@ -306,7 +198,7 @@ export class MeilisearchService {
   }
 
   private requestJson(
-    method: 'POST' | 'DELETE' | 'PATCH' | 'GET',
+    method: 'POST' | 'DELETE',
     url: string,
     payload: any,
     headers: Record<string, string>,
@@ -343,141 +235,10 @@ export class MeilisearchService {
       );
 
       request.on('error', reject);
-      if (payload !== undefined && method !== 'GET') {
+      if (payload !== undefined) {
         request.write(JSON.stringify(payload));
       }
       request.end();
     });
   }
-
-  private async enableVectorStore(): Promise<void> {
-    // Temporarily disabled to avoid the overhead of checking on every save.
-    // Re-enable by removing the early return below.
-    return;
-    if (this.vectorStoreEnabled) return; // eslint-disable-line no-unreachable
-    const meiliConfig = this.getConfig();
-    if (!meiliConfig) return;
-    const url = `${meiliConfig.host}/experimental-features`;
-    try {
-      const response = await this.requestJson(
-        'PATCH',
-        url,
-        { vectorStore: true },
-        this.buildHeaders(meiliConfig),
-      );
-      if (this.isSuccessStatus(response.status)) {
-        this.vectorStoreEnabled = true;
-        this.logger.log('Meilisearch vector store experimental feature enabled');
-      } else {
-        this.logger.warn(
-          `Failed to enable Meilisearch vector store: ${response.status} ${JSON.stringify(response.body)}`,
-        );
-      }
-    } catch (error) {
-      this.logger.warn(`Failed to enable Meilisearch vector store: ${error.message}`);
-    }
-  }
-
-  async ensureOpenAiEmbedder(
-    indexName: string,
-    config: OpenAiEmbedderConfig,
-  ): Promise<boolean> {
-    const meiliConfig = this.getConfig();
-    if (!meiliConfig || !config?.apiKey) return false;
-
-    await this.enableVectorStore();
-
-    const signature = JSON.stringify({
-      embedderName: config.embedderName,
-      model: config.model,
-      documentTemplate: config.documentTemplate,
-      apiKey: config.apiKey,
-    });
-    const cacheKey = `${indexName}:${config.embedderName}`;
-    if (this.embedderCache.get(cacheKey) === signature) {
-      return true;
-    }
-
-    const url = `${meiliConfig.host}/indexes/${encodeURIComponent(indexName)}/settings/embedders`;
-    try {
-      const response = await this.requestJson(
-        'PATCH',
-        url,
-        {
-          [config.embedderName]: {
-            source: 'openAi',
-            model: config.model,
-            apiKey: config.apiKey,
-            documentTemplate: config.documentTemplate,
-          },
-        },
-        this.buildHeaders(meiliConfig),
-      );
-      if (!this.isSuccessStatus(response.status)) {
-        this.logger.warn(
-          `Meilisearch embedder update failed for index ${indexName}: ${response.status}`,
-        );
-        this.logger.warn(
-          `Meilisearch embedder error body: ${JSON.stringify(response.body)}`,
-        );
-        return false;
-      }
-      const taskUid = response.body?.taskUid ?? response.body?.uid;
-      if (Number.isFinite(Number(taskUid))) {
-        const succeeded = await this.waitForTask(meiliConfig, Number(taskUid), 8000);
-        if (!succeeded) {
-          this.logger.warn(`Meilisearch embedder task did not succeed: ${taskUid}`);
-          return false;
-        }
-      }
-
-      const hasEmbedder = await this.hasEmbedder(meiliConfig, indexName, config.embedderName);
-      if (!hasEmbedder) {
-        this.logger.warn(`Meilisearch embedder missing after update: ${config.embedderName}`);
-        return false;
-      }
-      this.embedderCache.set(cacheKey, signature);
-      return true;
-    } catch (error) {
-      this.logger.warn(`Meilisearch embedder update failed: ${error.message}`);
-      return false;
-    }
-  }
-
-  private async waitForTask(
-    config: MeiliConfig,
-    taskUid: number,
-    timeoutMs = 8000,
-  ): Promise<boolean> {
-    const url = `${config.host}/tasks/${taskUid}`;
-    const start = Date.now();
-    while (Date.now() - start < timeoutMs) {
-      const response = await this.requestJson('GET', url, undefined, this.buildHeaders(config));
-      if (!this.isSuccessStatus(response.status)) {
-        return false;
-      }
-      const status = response.body?.status;
-      if (status === 'succeeded') return true;
-      if (status === 'failed' || status === 'canceled') {
-        this.logger.warn(`Meilisearch task ${taskUid} failed: ${JSON.stringify(response.body?.error)}`);
-        return false;
-      }
-      await new Promise((resolve) => setTimeout(resolve, 300));
-    }
-    return false;
-  }
-
-  private async hasEmbedder(
-    config: MeiliConfig,
-    indexName: string,
-    embedderName: string,
-  ): Promise<boolean> {
-    const url = `${config.host}/indexes/${encodeURIComponent(indexName)}/settings/embedders`;
-    const response = await this.requestJson('GET', url, undefined, this.buildHeaders(config));
-    if (!this.isSuccessStatus(response.status)) {
-      return false;
-    }
-    const embedders = response.body || {};
-    return Boolean(embedders && embedders[embedderName]);
-  }
 }

backend/src/tenant/tenant.controller.ts

@@ -16,45 +16,26 @@ import { TenantId } from './tenant.decorator';
 export class TenantController {
   constructor(private readonly tenantDbService: TenantDatabaseService) {}
 
-  /**
-   * Helper to find tenant by ID or domain
-   */
-  private async findTenant(identifier: string) {
-    const centralPrisma = getCentralPrisma();
-    
-    // Check if identifier is a CUID (tenant ID) or a domain
-    const isCUID = /^c[a-z0-9]{24}$/i.test(identifier);
-    
-    if (isCUID) {
-      // Look up by tenant ID directly
-      return centralPrisma.tenant.findUnique({
-        where: { id: identifier },
-        select: { id: true, integrationsConfig: true },
-      });
-    } else {
-      // Look up by domain
-      const domainRecord = await centralPrisma.domain.findUnique({
-        where: { domain: identifier },
-        include: { tenant: { select: { id: true, integrationsConfig: true } } },
-      });
-      return domainRecord?.tenant;
-    }
-  }
-
   /**
    * Get integrations configuration for the current tenant
    */
   @Get('integrations')
-  async getIntegrationsConfig(@TenantId() tenantIdentifier: string) {
-    const tenant = await this.findTenant(tenantIdentifier);
+  async getIntegrationsConfig(@TenantId() domain: string) {
+    const centralPrisma = getCentralPrisma();
+    
+    // Look up tenant by domain
+    const domainRecord = await centralPrisma.domain.findUnique({
+      where: { domain },
+      include: { tenant: { select: { id: true, integrationsConfig: true } } },
+    });
 
-    if (!tenant || !tenant.integrationsConfig) {
+    if (!domainRecord?.tenant || !domainRecord.tenant.integrationsConfig) {
       return { data: null };
     }
 
     // Decrypt the config
     const config = this.tenantDbService.decryptIntegrationsConfig(
-      tenant.integrationsConfig as any,
+      domainRecord.tenant.integrationsConfig as any,
     );
 
     // Return config with sensitive fields masked
@@ -68,26 +49,31 @@ export class TenantController {
    */
   @Put('integrations')
   async updateIntegrationsConfig(
-    @TenantId() tenantIdentifier: string,
+    @TenantId() domain: string,
     @Body() body: { integrationsConfig: any },
   ) {
     const { integrationsConfig } = body;
 
-    if (!tenantIdentifier) {
-      throw new Error('Tenant identifier is missing from request');
+    if (!domain) {
+      throw new Error('Domain is missing from request');
     }
 
-    const tenant = await this.findTenant(tenantIdentifier);
+    // Look up tenant by domain
+    const centralPrisma = getCentralPrisma();
+    const domainRecord = await centralPrisma.domain.findUnique({
+      where: { domain },
+      include: { tenant: { select: { id: true, integrationsConfig: true } } },
+    });
 
-    if (!tenant) {
-      throw new Error(`Tenant with identifier ${tenantIdentifier} not found`);
+    if (!domainRecord?.tenant) {
+      throw new Error(`Tenant with domain ${domain} not found`);
     }
 
     // Merge with existing config to preserve masked values
     let finalConfig = integrationsConfig;
-    if (tenant.integrationsConfig) {
+    if (domainRecord.tenant.integrationsConfig) {
       const existingConfig = this.tenantDbService.decryptIntegrationsConfig(
-        tenant.integrationsConfig as any,
+        domainRecord.tenant.integrationsConfig as any,
       );
 
       // Replace masked values with actual values from existing config
@@ -100,9 +86,8 @@ export class TenantController {
     );
 
     // Update in database
-    const centralPrisma = getCentralPrisma();
     await centralPrisma.tenant.update({
-      where: { id: tenant.id },
+      where: { id: domainRecord.tenant.id },
       data: {
         integrationsConfig: encryptedConfig as any,
       },

backend/src/tenant/tenant.middleware.ts

@@ -14,61 +14,61 @@ export class TenantMiddleware implements NestMiddleware {
     next: () => void,
   ) {
     try {
-      // Priority 1: Check x-tenant-subdomain header from Nitro BFF proxy
-      // This is the primary method when using the BFF architecture
-      let subdomain = req.headers['x-tenant-subdomain'] as string | null;
+      // Extract subdomain from hostname
+      const host = req.headers.host || '';
+      const hostname = host.split(':')[0]; // Remove port if present
+      
+      // Check Origin header to get frontend subdomain (for API calls)
+      const origin = req.headers.origin as string;
+      const referer = req.headers.referer as string;
+      
+      let parts = hostname.split('.');
+
+      this.logger.log(`Host header: ${host}, hostname: ${hostname}, origin: ${origin}, referer: ${referer}, parts: ${JSON.stringify(parts)}`);
+
+      // For local development, accept x-tenant-id header
       let tenantId = req.headers['x-tenant-id'] as string;
+      let subdomain: string | null = null;
 
-      if (subdomain) {
-        this.logger.log(`Using x-tenant-subdomain header: ${subdomain}`);
-      }
+      this.logger.log(`Host header: ${host}, hostname: ${hostname}, parts: ${JSON.stringify(parts)}, x-tenant-id: ${tenantId}`);
 
-      // Priority 2: Fall back to extracting subdomain from Origin/Host headers
-      // This supports direct backend access for development/testing
-      if (!subdomain && !tenantId) {
-        const host = req.headers.host || '';
-        const hostname = host.split(':')[0];
-        const origin = req.headers.origin as string;
-        const referer = req.headers.referer as string;
-        
-        let parts = hostname.split('.');
-
-        this.logger.log(`Host header: ${host}, hostname: ${hostname}, origin: ${origin}, referer: ${referer}`);
-
-        // Try to extract subdomain from Origin header first (for API calls from frontend)
-        if (origin) {
-          try {
-            const originUrl = new URL(origin);
-            const originHost = originUrl.hostname;
-            parts = originHost.split('.');
-            this.logger.log(`Using Origin header hostname: ${originHost}, parts: ${JSON.stringify(parts)}`);
-          } catch (error) {
-            this.logger.warn(`Failed to parse origin: ${origin}`);
-          }
-        } else if (referer) {
-          // Fallback to Referer if no Origin
-          try {
-            const refererUrl = new URL(referer);
-            const refererHost = refererUrl.hostname;
-            parts = refererHost.split('.');
-            this.logger.log(`Using Referer header hostname: ${refererHost}, parts: ${JSON.stringify(parts)}`);
-          } catch (error) {
-            this.logger.warn(`Failed to parse referer: ${referer}`);
-          }
+      // Try to extract subdomain from Origin header first (for API calls from frontend)
+      if (origin) {
+        try {
+          const originUrl = new URL(origin);
+          const originHost = originUrl.hostname;
+          parts = originHost.split('.');
+          this.logger.log(`Using Origin header hostname: ${originHost}, parts: ${JSON.stringify(parts)}`);
+        } catch (error) {
+          this.logger.warn(`Failed to parse origin: ${origin}`);
         }
-
-        // Extract subdomain (e.g., "tenant1" from "tenant1.routebox.co")
-        if (parts.length >= 3) {
-          subdomain = parts[0];
-          if (subdomain === 'www') {
-            subdomain = null;
-          }
-        } else if (parts.length === 2 && parts[1] === 'localhost') {
-          subdomain = parts[0];
+      } else if (referer && !tenantId) {
+        // Fallback to Referer if no Origin
+        try {
+          const refererUrl = new URL(referer);
+          const refererHost = refererUrl.hostname;
+          parts = refererHost.split('.');
+          this.logger.log(`Using Referer header hostname: ${refererHost}, parts: ${JSON.stringify(parts)}`);
+        } catch (error) {
+          this.logger.warn(`Failed to parse referer: ${referer}`);
         }
       }
 
-      this.logger.log(`Extracted subdomain: ${subdomain}, x-tenant-id: ${tenantId}`);
+      // Extract subdomain (e.g., "tenant1" from "tenant1.routebox.co")
+      // For production domains with 3+ parts, extract first part as subdomain
+      if (parts.length >= 3) {
+        subdomain = parts[0];
+        // Ignore www subdomain
+        if (subdomain === 'www') {
+          subdomain = null;
+        }
+      }
+      // For development (e.g., tenant1.localhost), also check 2 parts
+      else if (parts.length === 2 && parts[1] === 'localhost') {
+        subdomain = parts[0];
+      }
+
+      this.logger.log(`Extracted subdomain: ${subdomain}`);
 
       // Always attach subdomain to request if present
       if (subdomain) {
@@ -122,7 +122,7 @@ export class TenantMiddleware implements NestMiddleware {
         // Attach tenant info to request object
         (req as any).tenantId = tenantId;
       } else {
-        this.logger.warn(`No tenant identified from host: ${subdomain}`);
+        this.logger.warn(`No tenant identified from host: ${hostname}`);
       }
 
       next();

backend/src/voice/interfaces/integration-config.interface.ts

@@ -11,7 +11,6 @@ export interface OpenAIConfig {
   apiKey: string;
   assistantId?: string;
   model?: string;
-  embeddingModel?: string;
   voice?: string;
 }
 

backend/src/voice/voice.controller.ts

@@ -98,75 +98,37 @@ export class VoiceController {
 
   /**
    * TwiML for outbound calls from browser (Twilio Device)
-   * Twilio sends application/x-www-form-urlencoded data
    */
   @Post('twiml/outbound')
   async outboundTwiml(@Req() req: FastifyRequest, @Res() res: FastifyReply) {
-    // Parse body - Twilio sends URL-encoded form data
-    let body = req.body as any;
-    
-    // Handle case where body might be parsed as JSON key (URL-encoded string as key)
-    if (body && typeof body === 'object' && Object.keys(body).length === 1) {
-      const key = Object.keys(body)[0];
-      if (key.startsWith('{') || key.includes('=')) {
-        try {
-          // Try parsing as JSON if it looks like JSON
-          if (key.startsWith('{')) {
-            body = JSON.parse(key);
-          } else {
-            // Parse as URL-encoded
-            const params = new URLSearchParams(key);
-            body = Object.fromEntries(params.entries());
-          }
-        } catch (e) {
-          this.logger.warn(`Failed to re-parse body: ${e.message}`);
-        }
-      }
-    }
-
+    const body = req.body as any;
     const to = body.To;
-    const from = body.From; // Format: "client:tenantId:userId"
+    const from = body.From;
     const callSid = body.CallSid;
 
     this.logger.log(`=== TwiML OUTBOUND REQUEST RECEIVED ===`);
-    this.logger.log(`CallSid: ${callSid}, From: ${from}, To: ${to}`);
+    this.logger.log(`CallSid: ${callSid}, Body From: ${from}, Body To: ${to}`);
+    this.logger.log(`Full body: ${JSON.stringify(body)}`);
 
     try {
-      // Extract tenant ID from the client identity
-      // Format: "client:tenantId:userId"
-      let tenantId: string | null = null;
-      if (from && from.startsWith('client:')) {
-        const parts = from.replace('client:', '').split(':');
-        if (parts.length >= 2) {
-          tenantId = parts[0]; // First part is tenantId
-          this.logger.log(`Extracted tenantId from client identity: ${tenantId}`);
-        }
-      }
-
-      if (!tenantId) {
-        this.logger.error(`Could not extract tenant from From: ${from}`);
-        throw new Error('Could not determine tenant from call');
-      }
+      // Extract tenant domain from Host header
+      const host = req.headers.host || '';
+      const tenantDomain = host.split('.')[0]; // e.g., "tenant1" from "tenant1.routebox.co"
+      
+      this.logger.log(`Extracted tenant domain: ${tenantDomain}`);
 
       // Look up tenant's Twilio phone number from config
-      let callerId: string | undefined;
+      let callerId = to; // Fallback (will cause error if not found)
       try {
-        const { config } = await this.voiceService['getTwilioClient'](tenantId);
+        // Get Twilio config to find the phone number
+        const { config } = await this.voiceService['getTwilioClient'](tenantDomain);
         callerId = config.phoneNumber;
         this.logger.log(`Retrieved Twilio phone number for tenant: ${callerId}`);
       } catch (error: any) {
         this.logger.error(`Failed to get Twilio config: ${error.message}`);
-        throw error;
       }
 
-      if (!callerId) {
-        throw new Error('No caller ID configured for tenant');
-      }
-
-      const dialNumber = to?.trim();
-      if (!dialNumber) {
-        throw new Error('No destination number provided');
-      }
+      const dialNumber = to;
 
       this.logger.log(`Using callerId: ${callerId}, dialNumber: ${dialNumber}`);
 
@@ -183,9 +145,10 @@ export class VoiceController {
     } catch (error: any) {
       this.logger.error(`=== ERROR GENERATING TWIML ===`);
       this.logger.error(`Error: ${error.message}`);
+      this.logger.error(`Stack: ${error.stack}`);
       const errorTwiml = `<?xml version="1.0" encoding="UTF-8"?>
 <Response>
-  <Say>An error occurred while processing your call. ${error.message}</Say>
+  <Say>An error occurred while processing your call.</Say>
 </Response>`;
       res.type('text/xml').send(errorTwiml);
     }
@@ -193,33 +156,13 @@ export class VoiceController {
 
   /**
    * TwiML for inbound calls
-   * Twilio sends application/x-www-form-urlencoded data
    */
   @Post('twiml/inbound')
   async inboundTwiml(@Req() req: FastifyRequest, @Res() res: FastifyReply) {
-    // Parse body - Twilio sends URL-encoded form data
-    let body = req.body as any;
-    
-    // Handle case where body might be parsed incorrectly
-    if (body && typeof body === 'object' && Object.keys(body).length === 1) {
-      const key = Object.keys(body)[0];
-      if (key.startsWith('{') || key.includes('=')) {
-        try {
-          if (key.startsWith('{')) {
-            body = JSON.parse(key);
-          } else {
-            const params = new URLSearchParams(key);
-            body = Object.fromEntries(params.entries());
-          }
-        } catch (e) {
-          this.logger.warn(`Failed to re-parse body: ${e.message}`);
-        }
-      }
-    }
-
+    const body = req.body as any;
     const callSid = body.CallSid;
     const fromNumber = body.From;
-    const toNumber = body.To; // This is the Twilio phone number that was called
+    const toNumber = body.To;
 
     this.logger.log(`\n\n╔════════════════════════════════════════╗`);
     this.logger.log(`║ === INBOUND CALL RECEIVED ===`);
@@ -227,28 +170,19 @@ export class VoiceController {
     this.logger.log(`CallSid: ${callSid}`);
     this.logger.log(`From: ${fromNumber}`);
     this.logger.log(`To: ${toNumber}`);
+    this.logger.log(`Full body: ${JSON.stringify(body)}`);
 
     try {
-      // Look up tenant by the Twilio phone number that was called
-      const tenantInfo = await this.voiceService.findTenantByPhoneNumber(toNumber);
+      // Extract tenant domain from Host header
+      const host = req.headers.host || '';
+      const tenantDomain = host.split('.')[0]; // e.g., "tenant1" from "tenant1.routebox.co"
       
-      if (!tenantInfo) {
-        this.logger.error(`No tenant found for phone number: ${toNumber}`);
-        const twiml = `<?xml version="1.0" encoding="UTF-8"?>
-<Response>
-  <Say>Sorry, this number is not configured. Please contact support.</Say>
-  <Hangup/>
-</Response>`;
-        return res.type('text/xml').send(twiml);
-      }
-
-      const tenantId = tenantInfo.tenantId;
-      this.logger.log(`Found tenant: ${tenantId}`);
+      this.logger.log(`Extracted tenant domain: ${tenantDomain}`);
 
       // Get all connected users for this tenant
-      const connectedUsers = this.voiceGateway.getConnectedUsers(tenantId);
+      const connectedUsers = this.voiceGateway.getConnectedUsers(tenantDomain);
       
-      this.logger.log(`Connected users for tenant ${tenantId}: ${connectedUsers.length}`);
+      this.logger.log(`Connected users for tenant ${tenantDomain}: ${connectedUsers.length}`);
       if (connectedUsers.length > 0) {
         this.logger.log(`Connected user IDs: ${connectedUsers.join(', ')}`);
       }
@@ -264,22 +198,20 @@ export class VoiceController {
         return res.type('text/xml').send(twiml);
       }
 
-      // Build TwiML to dial all connected clients
-      // Client identity format is now: tenantId:userId
-      const clientElements = connectedUsers.map(userId => `    <Client>${tenantId}:${userId}</Client>`).join('\n');
+      // Build TwiML to dial all connected clients with Media Streams for AI
+      const clientElements = connectedUsers.map(userId => `    <Client>${userId}</Client>`).join('\n');
       
-      // Log the client identities being dialed
-      this.logger.log(`Client identities being dialed:`);
-      connectedUsers.forEach(userId => {
-        this.logger.log(`  - ${tenantId}:${userId}`);
-      });
-      
-      // Use wss:// for secure WebSocket
-      const host = req.headers.host || 'backend.routebox.co';
+      // Use wss:// for secure WebSocket (Traefik handles HTTPS)
       const streamUrl = `wss://${host}/api/voice/media-stream`;
       
       this.logger.log(`Stream URL: ${streamUrl}`);
       this.logger.log(`Dialing ${connectedUsers.length} client(s)...`);
+      this.logger.log(`Client IDs to dial: ${connectedUsers.join(', ')}`);
+      
+      // Verify we have client IDs in proper format
+      if (connectedUsers.length > 0) {
+        this.logger.log(`First Client ID format check: "${connectedUsers[0]}" (length: ${connectedUsers[0].length})`);
+      }
 
       // Notify connected users about incoming call via Socket.IO
       connectedUsers.forEach(userId => {
@@ -287,7 +219,7 @@ export class VoiceController {
           callSid,
           fromNumber,
           toNumber,
-          tenantId,
+          tenantDomain,
         });
       });
 
@@ -295,7 +227,7 @@ export class VoiceController {
 <Response>
   <Start>
     <Stream url="${streamUrl}">
-      <Parameter name="tenantId" value="${tenantId}"/>
+      <Parameter name="tenantId" value="${tenantDomain}"/>
       <Parameter name="userId" value="${connectedUsers[0]}"/>
     </Stream>
   </Start>
@@ -304,7 +236,7 @@ ${clientElements}
   </Dial>
 </Response>`;
 
-      this.logger.log(`✓ Returning inbound TwiML - dialing ${connectedUsers.length} client(s)`);
+      this.logger.log(`✓ Returning inbound TwiML with Media Streams - dialing ${connectedUsers.length} client(s)`);
       this.logger.log(`Generated TwiML:\n${twiml}\n`);
       res.type('text/xml').send(twiml);
     } catch (error: any) {

backend/src/voice/voice.gateway.ts

@@ -61,41 +61,33 @@ export class VoiceGateway
       const payload = await this.jwtService.verifyAsync(token);
       
       // Extract domain from origin header (e.g., http://tenant1.routebox.co:3001)
+      // The domains table stores just the subdomain part (e.g., "tenant1")
       const origin = client.handshake.headers.origin || client.handshake.headers.referer;
-      let subdomain = 'localhost';
+      let domain = 'localhost';
       
       if (origin) {
         try {
           const url = new URL(origin);
-          const hostname = url.hostname;
-          subdomain = hostname.split('.')[0];
+          const hostname = url.hostname; // e.g., tenant1.routebox.co or localhost
+          
+          // Extract first part of subdomain as domain
+          // tenant1.routebox.co -> tenant1
+          // localhost -> localhost
+          domain = hostname.split('.')[0];
         } catch (error) {
           this.logger.warn(`Failed to parse origin: ${origin}`);
         }
       }
       
-      // Resolve the actual tenantId (UUID) from the subdomain
-      let tenantId: string | null = null;
-      try {
-        const tenant = await this.tenantDbService.getTenantByDomain(subdomain);
-        if (tenant) {
-          tenantId = tenant.id;
-          this.logger.log(`Resolved tenant ${subdomain} -> ${tenantId}`);
-        }
-      } catch (error) {
-        this.logger.warn(`Failed to resolve tenant for subdomain ${subdomain}: ${error.message}`);
-      }
-
-      // Fall back to subdomain if tenant lookup fails
-      client.tenantId = tenantId || subdomain;
+      client.tenantId = domain; // Store the subdomain as tenantId
       client.userId = payload.sub;
-      client.tenantSlug = subdomain;
+      client.tenantSlug = domain; // Same as subdomain
 
       this.connectedUsers.set(client.userId, client);
       this.logger.log(
-        `✓ Client connected: ${client.id} (User: ${client.userId}, TenantId: ${client.tenantId}, Subdomain: ${subdomain})`,
+        `✓ Client connected: ${client.id} (User: ${client.userId}, Domain: ${domain})`,
       );
-      this.logger.log(`Total connected users in tenant ${client.tenantId}: ${this.getConnectedUsers(client.tenantId).length}`);
+      this.logger.log(`Total connected users in ${domain}: ${this.getConnectedUsers(domain).length}`);
 
       // Send current call state if any active call
       const activeCallSid = this.activeCallsByUser.get(client.userId);
@@ -311,14 +303,13 @@ export class VoiceGateway
 
   /**
    * Get connected users for a tenant
-   * @param tenantId - The tenant UUID to filter by
    */
-  getConnectedUsers(tenantId?: string): string[] {
+  getConnectedUsers(tenantDomain?: string): string[] {
     const userIds: string[] = [];
     
     for (const [userId, socket] of this.connectedUsers.entries()) {
-      // If tenantId specified, filter by tenant
-      if (!tenantId || socket.tenantId === tenantId) {
+      // If tenantDomain specified, filter by tenant
+      if (!tenantDomain || socket.tenantSlug === tenantDomain) {
         userIds.push(userId);
       }
     }

backend/src/voice/voice.service.ts

@@ -31,46 +31,46 @@ export class VoiceService {
   /**
    * Get Twilio client for a tenant
    */
-  private async getTwilioClient(tenantId: string): Promise<{ client: Twilio.Twilio; config: TwilioConfig; tenantId: string }> {
+  private async getTwilioClient(tenantIdOrDomain: string): Promise<{ client: Twilio.Twilio; config: TwilioConfig; tenantId: string }> {
     // Check cache first
-    if (this.twilioClients.has(tenantId)) {
+    if (this.twilioClients.has(tenantIdOrDomain)) {
       const centralPrisma = getCentralPrisma();
       
-      // Look up tenant by ID
-      const tenant = await centralPrisma.tenant.findUnique({
-        where: { id: tenantId },
-        select: { id: true, integrationsConfig: true },
+      // Look up tenant by domain
+      const domainRecord = await centralPrisma.domain.findUnique({
+        where: { domain: tenantIdOrDomain },
+        include: { tenant: { select: { id: true, integrationsConfig: true } } },
       });
 
-      const config = this.getIntegrationConfig(tenant?.integrationsConfig as any);
+      const config = this.getIntegrationConfig(domainRecord?.tenant?.integrationsConfig as any);
       return { 
-        client: this.twilioClients.get(tenantId), 
+        client: this.twilioClients.get(tenantIdOrDomain), 
         config: config.twilio,
-        tenantId: tenant.id 
+        tenantId: domainRecord.tenant.id 
       };
     }
 
     // Fetch tenant integrations config
     const centralPrisma = getCentralPrisma();
     
-    this.logger.log(`Looking up tenant: ${tenantId}`);
+    this.logger.log(`Looking up domain: ${tenantIdOrDomain}`);
     
-    const tenant = await centralPrisma.tenant.findUnique({
-      where: { id: tenantId },
-      select: { id: true, integrationsConfig: true },
+    const domainRecord = await centralPrisma.domain.findUnique({
+      where: { domain: tenantIdOrDomain },
+      include: { tenant: { select: { id: true, integrationsConfig: true } } },
     });
 
-    this.logger.log(`Tenant found: ${!!tenant}, Config: ${!!tenant?.integrationsConfig}`);
+    this.logger.log(`Domain record found: ${!!domainRecord}, Tenant: ${!!domainRecord?.tenant}, Config: ${!!domainRecord?.tenant?.integrationsConfig}`);
 
-    if (!tenant) {
-      throw new Error(`Tenant ${tenantId} not found`);
+    if (!domainRecord?.tenant) {
+      throw new Error(`Domain ${tenantIdOrDomain} not found`);
     }
 
-    if (!tenant.integrationsConfig) {
+    if (!domainRecord.tenant.integrationsConfig) {
       throw new Error('Tenant integrations config not found. Please configure Twilio credentials in Settings > Integrations');
     }
 
-    const config = this.getIntegrationConfig(tenant.integrationsConfig as any);
+    const config = this.getIntegrationConfig(domainRecord.tenant.integrationsConfig as any);
 
     this.logger.log(`Config decrypted: ${!!config.twilio}, AccountSid: ${config.twilio?.accountSid?.substring(0, 10)}..., AuthToken: ${config.twilio?.authToken?.substring(0, 10)}..., Phone: ${config.twilio?.phoneNumber}`);
 
@@ -79,9 +79,9 @@ export class VoiceService {
     }
 
     const client = Twilio.default(config.twilio.accountSid, config.twilio.authToken);
-    this.twilioClients.set(tenantId, client);
+    this.twilioClients.set(tenantIdOrDomain, client);
 
-    return { client, config: config.twilio, tenantId: tenant.id };
+    return { client, config: config.twilio, tenantId: domainRecord.tenant.id };
   }
 
   /**
@@ -105,64 +105,22 @@ export class VoiceService {
     return {};
   }
 
-  /**
-   * Find tenant by their configured Twilio phone number
-   * Used for inbound call routing
-   */
-  async findTenantByPhoneNumber(phoneNumber: string): Promise<{ tenantId: string; config: TwilioConfig } | null> {
-    const centralPrisma = getCentralPrisma();
-    
-    // Normalize phone number (remove spaces, ensure + prefix for comparison)
-    const normalizedPhone = phoneNumber.replace(/\s+/g, '').replace(/^(\d)/, '+$1');
-    
-    this.logger.log(`Looking up tenant by phone number: ${normalizedPhone}`);
-    
-    // Get all tenants with integrations config
-    const tenants = await centralPrisma.tenant.findMany({
-      where: {
-        integrationsConfig: { not: null },
-      },
-      select: { id: true, integrationsConfig: true },
-    });
-
-    for (const tenant of tenants) {
-      const config = this.getIntegrationConfig(tenant.integrationsConfig as any);
-      if (config.twilio?.phoneNumber) {
-        const tenantPhone = config.twilio.phoneNumber.replace(/\s+/g, '').replace(/^(\d)/, '+$1');
-        if (tenantPhone === normalizedPhone) {
-          this.logger.log(`Found tenant ${tenant.id} for phone number ${normalizedPhone}`);
-          return { tenantId: tenant.id, config: config.twilio };
-        }
-      }
-    }
-
-    this.logger.warn(`No tenant found for phone number: ${normalizedPhone}`);
-    return null;
-  }
-
   /**
    * Generate Twilio access token for browser Voice SDK
    */
-  async generateAccessToken(tenantId: string, userId: string): Promise<string> {
-    const { config, tenantId: resolvedTenantId } = await this.getTwilioClient(tenantId);
+  async generateAccessToken(tenantDomain: string, userId: string): Promise<string> {
+    const { config, tenantId } = await this.getTwilioClient(tenantDomain);
 
     if (!config.accountSid || !config.apiKey || !config.apiSecret) {
       throw new Error('Twilio API credentials not configured. Please add API Key and Secret in Settings > Integrations');
     }
 
-    // Include tenantId in the identity so we can extract it in TwiML webhooks
-    // Format: tenantId:userId
-    const identity = `${resolvedTenantId}:${userId}`;
-    
-    this.logger.log(`Generating access token with identity: ${identity}`);
-    this.logger.log(`  Input tenantId: ${tenantId}, Resolved tenantId: ${resolvedTenantId}, userId: ${userId}`);
-
     // Create an access token
     const token = new AccessToken(
       config.accountSid,
       config.apiKey,
       config.apiSecret,
-      { identity, ttl: 3600 } // 1 hour expiry
+      { identity: userId, ttl: 3600 } // 1 hour expiry
     );
 
     // Create a Voice grant
@@ -478,28 +436,20 @@ export class VoiceService {
     const { callSid, tenantId, userId } = params;
 
     try {
-      // Get OpenAI config - tenantId might be a domain or a tenant ID (UUID or CUID)
+      // Get OpenAI config - tenantId might be a domain, so look it up
       const centralPrisma = getCentralPrisma();
       
-      // Detect if tenantId looks like an ID (UUID or CUID) or a domain name
-      // UUIDs: 8-4-4-4-12 hex format
-      // CUIDs: 25 character alphanumeric starting with 'c'
-      const isUUID = /^[0-9a-f]{8}-[0-9a-f]{4}-/i.test(tenantId);
-      const isCUID = /^c[a-z0-9]{24}$/i.test(tenantId);
-      const isId = isUUID || isCUID;
-      
+      // Try to find tenant by domain first (if tenantId is like "tenant1")
       let tenant;
-      if (!isId) {
-        // Looks like a domain, not an ID
-        this.logger.log(`Looking up tenant by domain: ${tenantId}`);
+      if (!tenantId.match(/^[0-9a-f]{8}-[0-9a-f]{4}-/i)) {
+        // Looks like a domain, not a UUID
         const domainRecord = await centralPrisma.domain.findUnique({
           where: { domain: tenantId },
           include: { tenant: { select: { id: true, integrationsConfig: true } } },
         });
         tenant = domainRecord?.tenant;
       } else {
-        // It's an ID (UUID or CUID)
-        this.logger.log(`Looking up tenant by ID: ${tenantId}`);
+        // It's a UUID
         tenant = await centralPrisma.tenant.findUnique({
           where: { id: tenantId },
           select: { id: true, integrationsConfig: true },

frontend/components/LoginForm.vue

@@ -3,32 +3,90 @@ import { Button } from '@/components/ui/button'
 import { Input } from '@/components/ui/input'
 import { Label } from '@/components/ui/label'
 
+const config = useRuntimeConfig()
 const router = useRouter()
 const { toast } = useToast()
-const { login, isLoading } = useAuth()
 
+// Cookie for server-side auth check
+const tokenCookie = useCookie('token')
+
+// Extract subdomain from hostname (e.g., tenant1.localhost → tenant1)
+const getSubdomain = () => {
+  if (!import.meta.client) return null
+  const hostname = window.location.hostname
+  const parts = hostname.split('.')
+  
+  console.log('Extracting subdomain from:', hostname, 'parts:', parts)
+  
+  // For localhost development: tenant1.localhost or localhost
+  if (hostname === 'localhost' || hostname === '127.0.0.1') {
+    return null // Use default tenant for plain localhost
+  }
+  
+  // For subdomains like tenant1.routebox.co or tenant1.localhost
+  if (parts.length >= 2 && parts[0] !== 'www') {
+    console.log('Using subdomain:', parts[0])
+    return parts[0] // Return subdomain
+  }
+  
+  return null
+}
+
+const subdomain = ref(getSubdomain())
 const email = ref('')
 const password = ref('')
+const loading = ref(false)
 const error = ref('')
 
 const handleLogin = async () => {
   try {
+    loading.value = true
     error.value = ''
 
-    // Use the BFF login endpoint via useAuth
-    const result = await login(email.value, password.value)
-
-    if (result.success) {
-      toast.success('Login successful!')
-      // Redirect to home
-      router.push('/')
-    } else {
-      error.value = result.error || 'Login failed'
-      toast.error(result.error || 'Login failed')
+    const headers: Record<string, string> = {
+      'Content-Type': 'application/json',
     }
+
+    // Only send x-tenant-id if we have a subdomain
+    if (subdomain.value) {
+      headers['x-tenant-id'] = subdomain.value
+    }
+
+    const response = await fetch(`${config.public.apiBaseUrl}/api/auth/login`, {
+      method: 'POST',
+      headers,
+      body: JSON.stringify({
+        email: email.value,
+        password: password.value,
+      }),
+    })
+
+    if (!response.ok) {
+      const data = await response.json()
+      throw new Error(data.message || 'Login failed')
+    }
+
+    const data = await response.json()
+
+    // Store credentials in localStorage
+    // Store the tenant ID that was used for login
+    const tenantToStore = subdomain.value || data.user?.tenantId || 'tenant1'
+    localStorage.setItem('tenantId', tenantToStore)
+    localStorage.setItem('token', data.access_token)
+    localStorage.setItem('user', JSON.stringify(data.user))
+    
+    // Also store token in cookie for server-side auth check
+    tokenCookie.value = data.access_token
+
+    toast.success('Login successful!')
+    
+    // Redirect to home
+    router.push('/')
   } catch (e: any) {
     error.value = e.message || 'Login failed'
     toast.error(e.message || 'Login failed')
+  } finally {
+    loading.value = false
   }
 }
 </script>
@@ -60,8 +118,8 @@ const handleLogin = async () => {
         </div>
         <Input id="password" v-model="password" type="password" required />
       </div>
-      <Button type="submit" class="w-full" :disabled="isLoading">
-        {{ isLoading ? 'Logging in...' : 'Login' }}
+      <Button type="submit" class="w-full" :disabled="loading">
+        {{ loading ? 'Logging in...' : 'Login' }}
       </Button>
     </div>
     <div class="text-center text-sm">

frontend/components/RecordSharing.vue

@@ -186,8 +186,6 @@ interface Props {
   objectApiName: string;
   recordId: string;
   ownerId?: string;
-  /** Optional base URL override for shares API. Defaults to /runtime/objects/{objectApiName}/records/{recordId}/shares */
-  basePath?: string;
 }
 
 const props = defineProps<Props>();
@@ -195,11 +193,6 @@ const props = defineProps<Props>();
 const { api } = useApi();
 const { toast } = useToast();
 
-/** Computed base path for all share API calls */
-const sharesBasePath = computed(() =>
-  props.basePath || `/runtime/objects/${props.objectApiName}/records/${props.recordId}/shares`
-);
-
 const loading = ref(true);
 const sharing = ref(false);
 const removing = ref<string | null>(null);
@@ -243,7 +236,9 @@ const loadShares = async () => {
   try {
     loading.value = true;
     error.value = null;
-    const response = await api.get(sharesBasePath.value);
+    const response = await api.get(
+      `/runtime/objects/${props.objectApiName}/records/${props.recordId}/shares`
+    );
     shares.value = response || [];
   } catch (e: any) {
     console.error('Failed to load shares:', e);
@@ -291,7 +286,7 @@ const createShare = async () => {
     console.log('Final payload:', payload);
     
     await api.post(
-      sharesBasePath.value,
+      `/runtime/objects/${props.objectApiName}/records/${props.recordId}/shares`,
       payload
     );
     toast.success('Record shared successfully');
@@ -318,7 +313,7 @@ const removeShare = async (shareId: string) => {
   try {
     removing.value = shareId;
     await api.delete(
-      `${sharesBasePath.value}/${shareId}`
+      `/runtime/objects/${props.objectApiName}/records/${props.recordId}/shares/${shareId}`
     );
     toast.success('Share removed successfully');
     await loadShares();

frontend/components/SavedViewPanel.vue

@@ -1,234 +0,0 @@
-<script setup lang="ts">
-import { ref, computed, nextTick } from 'vue'
-import {
-  Sheet,
-  SheetContent,
-  SheetHeader,
-  SheetTitle,
-  SheetDescription,
-} from '@/components/ui/sheet'
-import { Button } from '@/components/ui/button'
-import { Input } from '@/components/ui/input'
-import { Badge } from '@/components/ui/badge'
-import { Separator } from '@/components/ui/separator'
-import { Pencil, Trash2, Users, Check, X, ChevronLeft } from 'lucide-vue-next'
-import type { SavedView, UpdateSavedViewPayload } from '@/composables/useSavedViews'
-
-interface Props {
-  open: boolean
-  views: SavedView[]
-  objectLabel: string
-  activeViewId?: string | null
-}
-
-const props = withDefaults(defineProps<Props>(), {
-  activeViewId: null,
-})
-
-const emit = defineEmits<{
-  'update:open': [value: boolean]
-  'apply-view': [view: SavedView]
-  'update-view': [id: string, payload: UpdateSavedViewPayload]
-  'delete-view': [view: SavedView]
-}>()
-
-const editingId = ref<string | null>(null)
-const editName = ref('')
-const deletingId = ref<string | null>(null)
-
-// Sharing sub-view: when set, renders RecordSharing for this view
-const sharingView = ref<SavedView | null>(null)
-
-const ownViews = computed(() => props.views.filter(v => v.isOwner))
-const sharedViews = computed(() => props.views.filter(v => !v.isOwner))
-
-function startEdit(view: SavedView) {
-  editingId.value = view.id
-  editName.value = view.name
-}
-
-function cancelEdit() {
-  editingId.value = null
-  editName.value = ''
-}
-
-function commitEdit(view: SavedView) {
-  const name = editName.value.trim()
-  if (name && name !== view.name) {
-    emit('update-view', view.id, { name })
-  }
-  cancelEdit()
-}
-
-function openSharing(view: SavedView) {
-  sharingView.value = view
-}
-
-function closeSharing() {
-  sharingView.value = null
-}
-
-function confirmDelete(view: SavedView) {
-  deletingId.value = view.id
-}
-
-function cancelDelete() {
-  deletingId.value = null
-}
-
-function executeDelete(view: SavedView) {
-  emit('delete-view', view)
-  deletingId.value = null
-}
-</script>
-
-<template>
-  <Sheet :open="open" @update:open="emit('update:open', $event)">
-    <SheetContent class="w-[420px] sm:w-[520px] overflow-y-auto">
-
-      <!-- ─── Sharing sub-view ─── -->
-      <template v-if="sharingView">
-        <SheetHeader class="mb-4">
-          <div class="flex items-center gap-2">
-            <Button size="icon" variant="ghost" class="h-7 w-7 -ml-1" @click="closeSharing">
-              <ChevronLeft class="h-4 w-4" />
-            </Button>
-            <div>
-              <SheetTitle>Share "{{ sharingView.name }}"</SheetTitle>
-              <SheetDescription>
-                Grant access to specific users for this saved view.
-              </SheetDescription>
-            </div>
-          </div>
-        </SheetHeader>
-
-        <RecordSharing
-          object-api-name="SavedListView"
-          :record-id="sharingView.id"
-          :owner-id="sharingView.userId"
-          :base-path="`/saved-views/${sharingView.id}/shares`"
-        />
-      </template>
-
-      <!-- ─── Main view list ─── -->
-      <template v-else>
-        <SheetHeader class="mb-4">
-          <SheetTitle>{{ objectLabel }} — Saved Views</SheetTitle>
-          <SheetDescription>
-            Manage your saved searches. Share views with specific users from your workspace.
-          </SheetDescription>
-        </SheetHeader>
-
-        <!-- Own Views -->
-        <section>
-          <p class="text-xs font-semibold text-muted-foreground uppercase tracking-wide mb-2">
-            My Views
-          </p>
-
-          <div v-if="ownViews.length === 0" class="text-sm text-muted-foreground py-3">
-            You have no saved views yet. Run a search and click <strong>Save view</strong>.
-          </div>
-
-          <ul class="space-y-1">
-            <li
-              v-for="view in ownViews"
-              :key="view.id"
-              class="group rounded-md border bg-card px-3 py-2"
-            >
-              <!-- Confirm delete row -->
-              <div v-if="deletingId === view.id" class="flex items-center gap-2">
-                <span class="flex-1 text-sm text-destructive">Delete "{{ view.name }}"?</span>
-                <Button size="sm" variant="destructive" @click="executeDelete(view)">Delete</Button>
-                <Button size="sm" variant="outline" @click="cancelDelete">Cancel</Button>
-              </div>
-
-              <!-- Edit name row -->
-              <div v-else-if="editingId === view.id" class="flex items-center gap-2">
-                <Input
-                  v-model="editName"
-                  class="h-7 flex-1 text-sm"
-                  @keyup.enter="commitEdit(view)"
-                  @keyup.escape="cancelEdit"
-                  autofocus
-                />
-                <Button size="icon" variant="ghost" class="h-7 w-7" @click="commitEdit(view)">
-                  <Check class="h-3.5 w-3.5" />
-                </Button>
-                <Button size="icon" variant="ghost" class="h-7 w-7" @click="cancelEdit">
-                  <X class="h-3.5 w-3.5" />
-                </Button>
-              </div>
-
-              <!-- Normal row -->
-              <div v-else class="flex items-center gap-2 min-h-[28px]">
-                <!-- View name (click to apply) -->
-                <button
-                  class="flex-1 text-left text-sm truncate hover:text-primary transition-colors"
-                  :class="{ 'font-medium text-primary': activeViewId === view.id }"
-                  @click="emit('apply-view', view); emit('update:open', false)"
-                >
-                  {{ view.name }}
-                </button>
-
-                <!-- Actions (visible on hover) -->
-                <div class="flex items-center gap-1 opacity-0 group-hover:opacity-100 transition-opacity">
-                  <Button size="icon" variant="ghost" class="h-6 w-6" title="Rename" @click="startEdit(view)">
-                    <Pencil class="h-3 w-3" />
-                  </Button>
-                  <Button
-                    size="icon"
-                    variant="ghost"
-                    class="h-6 w-6"
-                    title="Share"
-                    @click="openSharing(view)"
-                  >
-                    <Users class="h-3 w-3" />
-                  </Button>
-                  <Button size="icon" variant="ghost" class="h-6 w-6 text-destructive hover:text-destructive" title="Delete" @click="confirmDelete(view)">
-                    <Trash2 class="h-3 w-3" />
-                  </Button>
-                </div>
-              </div>
-
-              <!-- Description -->
-              <p
-                v-if="view.description && editingId !== view.id && deletingId !== view.id"
-                class="text-xs text-muted-foreground mt-1 truncate"
-              >
-                {{ view.description }}
-              </p>
-            </li>
-          </ul>
-        </section>
-
-        <!-- Shared views by others -->
-        <template v-if="sharedViews.length > 0">
-          <Separator class="my-4" />
-          <section>
-            <p class="text-xs font-semibold text-muted-foreground uppercase tracking-wide mb-2">
-              Shared with me
-            </p>
-            <ul class="space-y-1">
-              <li
-                v-for="view in sharedViews"
-                :key="view.id"
-                class="rounded-md border bg-card px-3 py-2"
-              >
-                <button
-                  class="w-full text-left text-sm truncate hover:text-primary transition-colors"
-                  :class="{ 'font-medium text-primary': activeViewId === view.id }"
-                  @click="emit('apply-view', view); emit('update:open', false)"
-                >
-                  {{ view.name }}
-                </button>
-                <p v-if="view.description" class="text-xs text-muted-foreground mt-1 truncate">
-                  {{ view.description }}
-                </p>
-              </li>
-            </ul>
-          </section>
-        </template>
-      </template>
-    </SheetContent>
-  </Sheet>
-</template>

frontend/components/fields/FieldRenderer.vue

@@ -249,51 +249,6 @@ const handleRelationTypeUpdate = (value: string | null) => {
         </SelectContent>
       </Select>
 
-      <!-- Multi-Select -->
-      <div v-else-if="field.type === FieldType.MULTI_SELECT" class="space-y-2">
-        <div class="flex flex-wrap gap-1 min-h-[36px] rounded-md border border-input bg-background px-3 py-2">
-          <Badge
-            v-for="selectedVal in (Array.isArray(value) ? value : [])"
-            :key="String(selectedVal)"
-            variant="secondary"
-            class="gap-1 cursor-pointer"
-            @click="value = (value || []).filter((v: any) => v !== selectedVal)"
-          >
-            {{ field.options?.find(o => o.value === selectedVal)?.label || selectedVal }}
-            <span class="text-xs ml-1">&times;</span>
-          </Badge>
-          <span v-if="!value || (Array.isArray(value) && value.length === 0)" class="text-sm text-muted-foreground">
-            {{ field.placeholder || 'Select options...' }}
-          </span>
-        </div>
-        <div class="space-y-1">
-          <div
-            v-for="option in field.options"
-            :key="String(option.value)"
-            class="flex items-center gap-2"
-          >
-            <Checkbox
-              :id="`${field.id}-${option.value}`"
-              :checked="Array.isArray(value) && value.includes(option.value)"
-              @update:checked="(checked: boolean) => {
-                const current = Array.isArray(value) ? [...value] : []
-                if (checked) {
-                  current.push(option.value)
-                } else {
-                  const idx = current.indexOf(option.value)
-                  if (idx > -1) current.splice(idx, 1)
-                }
-                value = current
-              }"
-              :disabled="field.isReadOnly"
-            />
-            <Label :for="`${field.id}-${option.value}`" class="text-sm font-normal cursor-pointer">
-              {{ option.label }}
-            </Label>
-          </div>
-        </div>
-      </div>
-
       <!-- Boolean - Checkbox -->
       <div v-else-if="field.type === FieldType.BOOLEAN" class="flex items-center gap-2">
         <Checkbox :id="field.id" v-model:checked="value" :disabled="field.isReadOnly" />

frontend/components/knowledge/RecordCommentsPanel.vue

@@ -1,181 +0,0 @@
-<script setup lang="ts">
-import { ref, watch, computed } from 'vue'
-import { Card, CardContent, CardHeader, CardTitle } from '@/components/ui/card'
-import { Button } from '@/components/ui/button'
-import { Textarea } from '@/components/ui/textarea'
-import { Separator } from '@/components/ui/separator'
-import { useApi } from '@/composables/useApi'
-import { useAuth } from '@/composables/useAuth'
-
-type CommentRecord = {
-  id: string
-  content: string
-  author_user_id: string
-  created_at: string
-  updated_at: string
-}
-
-interface Props {
-  objectApiName: string
-  recordId: string
-}
-
-const props = defineProps<Props>()
-const { api } = useApi()
-const { user } = useAuth()
-
-const comments = ref<CommentRecord[]>([])
-const loading = ref(false)
-const error = ref<string | null>(null)
-const newComment = ref('')
-const saving = ref(false)
-const editingId = ref<string | null>(null)
-const editContent = ref('')
-
-const isOwner = (comment: CommentRecord) => comment.author_user_id === user.value?.id
-
-const formatDate = (value?: string) => {
-  if (!value) return ''
-  const date = new Date(value)
-  if (Number.isNaN(date.getTime())) return value
-  return date.toLocaleString()
-}
-
-const canSubmit = computed(() => newComment.value.trim().length > 0 && !saving.value)
-const canSaveEdit = computed(() => editContent.value.trim().length > 0 && !saving.value)
-
-const fetchComments = async () => {
-  if (!props.objectApiName || !props.recordId) return
-  loading.value = true
-  error.value = null
-  try {
-    const data = await api.get(`/knowledge/comments/${props.objectApiName}/${props.recordId}`)
-    comments.value = Array.isArray(data) ? data : []
-  } catch (e: any) {
-    error.value = e.message || 'Failed to load comments'
-  } finally {
-    loading.value = false
-  }
-}
-
-const addComment = async () => {
-  if (!canSubmit.value) return
-  saving.value = true
-  try {
-    await api.post('/knowledge/comments', {
-      parentObjectApiName: props.objectApiName,
-      parentRecordId: props.recordId,
-      content: newComment.value.trim(),
-    })
-    newComment.value = ''
-    await fetchComments()
-  } catch (e: any) {
-    error.value = e.message || 'Failed to add comment'
-  } finally {
-    saving.value = false
-  }
-}
-
-const startEdit = (comment: CommentRecord) => {
-  editingId.value = comment.id
-  editContent.value = comment.content
-}
-
-const cancelEdit = () => {
-  editingId.value = null
-  editContent.value = ''
-}
-
-const saveEdit = async () => {
-  if (!editingId.value || !canSaveEdit.value) return
-  saving.value = true
-  try {
-    await api.patch(`/knowledge/comments/${editingId.value}`, {
-      content: editContent.value.trim(),
-    })
-    editingId.value = null
-    editContent.value = ''
-    await fetchComments()
-  } catch (e: any) {
-    error.value = e.message || 'Failed to update comment'
-  } finally {
-    saving.value = false
-  }
-}
-
-const deleteComment = async (comment: CommentRecord) => {
-  if (!confirm('Delete this comment?')) return
-  saving.value = true
-  try {
-    await api.delete(`/knowledge/comments/${comment.id}`)
-    await fetchComments()
-  } catch (e: any) {
-    error.value = e.message || 'Failed to delete comment'
-  } finally {
-    saving.value = false
-  }
-}
-
-watch(
-  () => [props.objectApiName, props.recordId],
-  () => {
-    fetchComments()
-  },
-  { immediate: true },
-)
-</script>
-
-<template>
-  <Card>
-    <CardHeader>
-      <CardTitle>Comments</CardTitle>
-    </CardHeader>
-    <CardContent class="space-y-4">
-      <div class="space-y-3">
-        <Textarea
-          v-model="newComment"
-          placeholder="Add a comment..."
-          :disabled="saving"
-          class="min-h-[96px]"
-        />
-        <div class="flex items-center justify-between">
-          <p class="text-sm text-muted-foreground" v-if="error">{{ error }}</p>
-          <Button size="sm" :disabled="!canSubmit" @click="addComment">
-            Add Comment
-          </Button>
-        </div>
-      </div>
-
-      <Separator />
-
-      <div v-if="loading" class="text-sm text-muted-foreground">Loading comments...</div>
-      <div v-else-if="comments.length === 0" class="text-sm text-muted-foreground">
-        No comments yet.
-      </div>
-      <div v-else class="space-y-4">
-        <div v-for="comment in comments" :key="comment.id" class="rounded-lg border p-4 space-y-2">
-          <div class="flex items-center justify-between">
-            <div class="text-xs text-muted-foreground">
-              <span>Author: {{ comment.author_user_id }}</span>
-              <span class="mx-2">•</span>
-              <span>{{ formatDate(comment.created_at) }}</span>
-            </div>
-            <div class="flex items-center gap-2" v-if="isOwner(comment)">
-              <Button variant="ghost" size="sm" @click="startEdit(comment)">Edit</Button>
-              <Button variant="ghost" size="sm" @click="deleteComment(comment)">Delete</Button>
-            </div>
-          </div>
-
-          <div v-if="editingId === comment.id" class="space-y-2">
-            <Textarea v-model="editContent" :disabled="saving" class="min-h-[80px]" />
-            <div class="flex items-center gap-2">
-              <Button size="sm" :disabled="!canSaveEdit" @click="saveEdit">Save</Button>
-              <Button variant="ghost" size="sm" @click="cancelEdit">Cancel</Button>
-            </div>
-          </div>
-          <p v-else class="text-sm whitespace-pre-line">{{ comment.content }}</p>
-        </div>
-      </div>
-    </CardContent>
-  </Card>
-</template>

frontend/components/knowledge/SemanticLinksPanel.vue

@@ -1,237 +0,0 @@
-<script setup lang="ts">
-import { ref, watch, computed } from 'vue'
-import { Card, CardContent, CardHeader, CardTitle } from '@/components/ui/card'
-import { Button } from '@/components/ui/button'
-import { Tabs, TabsContent, TabsList, TabsTrigger } from '@/components/ui/tabs'
-import { Separator } from '@/components/ui/separator'
-import { useApi } from '@/composables/useApi'
-
-type SemanticLink = {
-  id: string
-  source_entity_type: string
-  source_entity_id: string
-  target_entity_type: string
-  target_entity_id: string
-  source_entity_label?: string
-  target_entity_label?: string
-  source_entity_name?: string
-  target_entity_name?: string
-  link_type: string
-  status: string
-  origin: string
-  confidence?: number
-  reason?: string
-  evidence?: any
-  updated_at?: string
-}
-
-interface Props {
-  objectApiName: string
-  recordId: string
-}
-
-const props = defineProps<Props>()
-const { api } = useApi()
-
-const links = ref<SemanticLink[]>([])
-const loading = ref(false)
-const error = ref<string | null>(null)
-const activeTab = ref<'all' | 'suggested' | 'approved' | 'rejected' | 'dismissed'>('suggested')
-
-const formatDate = (value?: string) => {
-  if (!value) return ''
-  const date = new Date(value)
-  if (Number.isNaN(date.getTime())) return value
-  return date.toLocaleString()
-}
-
-const formatConfidence = (value?: number) => {
-  if (value === undefined || value === null) return '—'
-  return `${Math.round(value * 100)}%`
-}
-
-const getOtherSide = (link: SemanticLink) => {
-  const isSource =
-    link.source_entity_type === props.objectApiName &&
-    link.source_entity_id === props.recordId
-  return {
-    entityType: isSource ? link.target_entity_type : link.source_entity_type,
-    entityId: isSource ? link.target_entity_id : link.source_entity_id,
-    entityLabel: isSource ? link.target_entity_label : link.source_entity_label,
-    entityName: isSource ? link.target_entity_name : link.source_entity_name,
-  }
-}
-
-const formatLinkType = (value?: string) => {
-  if (!value) return 'Related'
-  return value
-    .replace(/_/g, ' ')
-    .replace(/\b\w/g, (c) => c.toUpperCase())
-}
-
-const parseEvidence = (raw: any) => {
-  if (!raw) return null
-  if (typeof raw === 'object') return raw
-  try {
-    return JSON.parse(raw)
-  } catch {
-    return null
-  }
-}
-
-const fetchLinks = async () => {
-  if (!props.objectApiName || !props.recordId) return
-  loading.value = true
-  error.value = null
-  try {
-    const params =
-      activeTab.value === 'all'
-        ? undefined
-        : { status: activeTab.value }
-    const data = await api.get(`/knowledge/semantic/links/${props.objectApiName}/${props.recordId}`, {
-      params,
-    })
-    links.value = Array.isArray(data) ? data : []
-  } catch (e: any) {
-    error.value = e.message || 'Failed to load semantic links'
-  } finally {
-    loading.value = false
-  }
-}
-
-const reviewLink = async (id: string, status: 'approved' | 'rejected' | 'dismissed') => {
-  try {
-    await api.patch(`/knowledge/semantic/links/${id}/review`, { status })
-    await fetchLinks()
-  } catch (e: any) {
-    error.value = e.message || 'Failed to update link'
-  }
-}
-
-const canApprove = (status: string) => status !== 'approved'
-const canReject = (status: string) => status !== 'rejected'
-const canDismiss = (status: string) => status !== 'dismissed'
-
-watch(
-  () => [props.objectApiName, props.recordId, activeTab.value],
-  () => {
-    fetchLinks()
-  },
-  { immediate: true },
-)
-</script>
-
-<template>
-  <Card>
-    <CardHeader class="flex flex-row items-center justify-between">
-      <CardTitle>Semantic Links</CardTitle>
-      <Button variant="ghost" size="sm" @click="fetchLinks">Refresh</Button>
-    </CardHeader>
-    <CardContent class="space-y-4">
-      <Tabs v-model="activeTab" class="space-y-4">
-        <TabsList>
-          <TabsTrigger value="suggested">Suggested</TabsTrigger>
-          <TabsTrigger value="approved">Approved</TabsTrigger>
-          <TabsTrigger value="rejected">Rejected</TabsTrigger>
-          <TabsTrigger value="dismissed">Dismissed</TabsTrigger>
-          <TabsTrigger value="all">All</TabsTrigger>
-        </TabsList>
-
-        <TabsContent :value="activeTab" class="space-y-4">
-          <div v-if="loading" class="text-sm text-muted-foreground">
-            Loading links...
-          </div>
-          <div v-else-if="error" class="text-sm text-destructive">
-            {{ error }}
-          </div>
-          <div v-else-if="links.length === 0" class="text-sm text-muted-foreground">
-            No links found.
-          </div>
-          <div v-else class="space-y-4">
-            <div
-              v-for="link in links"
-              :key="link.id"
-              class="rounded-lg border p-4 space-y-3"
-            >
-              <div class="flex flex-wrap items-center justify-between gap-2">
-                <div class="text-sm font-medium">
-                  {{ getOtherSide(link).entityLabel || getOtherSide(link).entityType }} ·
-                  {{ getOtherSide(link).entityName || getOtherSide(link).entityId }}
-                </div>
-                <div class="text-xs text-muted-foreground">
-                  {{ formatLinkType(link.link_type) }} • {{ link.origin }} • {{ formatConfidence(link.confidence) }}
-                </div>
-              </div>
-
-              <div class="text-xs text-muted-foreground">
-                Status: <span class="font-medium text-foreground">{{ link.status }}</span>
-                <span v-if="link.updated_at" class="ml-2">Updated: {{ formatDate(link.updated_at) }}</span>
-              </div>
-
-              <p v-if="link.reason" class="text-sm">{{ link.reason }}</p>
-
-              <div v-if="parseEvidence(link.evidence)" class="text-xs text-muted-foreground space-y-2">
-                <Separator />
-                <div>
-                  <div class="font-medium text-foreground">Evidence</div>
-                  <p v-if="parseEvidence(link.evidence)?.explanation" class="mt-1 text-foreground">
-                    {{ parseEvidence(link.evidence).explanation }}
-                  </p>
-                  <div v-if="parseEvidence(link.evidence)?.matchedSignals?.length" class="mt-2">
-                    <div>Matched context:</div>
-                    <ul class="list-disc pl-4">
-                      <li
-                        v-for="(signal, idx) in parseEvidence(link.evidence).matchedSignals"
-                        :key="idx"
-                      >
-                        {{ signal }}
-                      </li>
-                    </ul>
-                  </div>
-                  <div v-if="parseEvidence(link.evidence)?.matchedChunks?.length" class="mt-2">
-                    <div>Matched excerpts:</div>
-                    <ul class="list-disc pl-4">
-                      <li
-                        v-for="(match, idx) in parseEvidence(link.evidence).matchedChunks"
-                        :key="idx"
-                      >
-                        {{ match.sourceKind }}: {{ match.text }}
-                      </li>
-                    </ul>
-                  </div>
-                </div>
-              </div>
-
-              <div class="flex items-center gap-2">
-                <Button
-                  size="sm"
-                  variant="outline"
-                  @click="reviewLink(link.id, 'approved')"
-                  :disabled="!canApprove(link.status)"
-                >
-                  Approve
-                </Button>
-                <Button
-                  size="sm"
-                  variant="outline"
-                  @click="reviewLink(link.id, 'rejected')"
-                  :disabled="!canReject(link.status)"
-                >
-                  Reject
-                </Button>
-                <Button
-                  size="sm"
-                  variant="outline"
-                  @click="reviewLink(link.id, 'dismissed')"
-                  :disabled="!canDismiss(link.status)"
-                >
-                  Dismiss
-                </Button>
-              </div>
-            </div>
-          </div>
-        </TabsContent>
-      </Tabs>
-    </CardContent>
-  </Card>
-</template>

frontend/components/ui/dropdown-menu/DropdownMenuSeparator.vue

@@ -1,16 +0,0 @@
-<script setup lang="ts">
-import { DropdownMenuSeparator, type DropdownMenuSeparatorProps, useForwardProps } from 'reka-ui'
-import type { HTMLAttributes } from 'vue'
-import { cn } from '@/lib/utils'
-
-const props = defineProps<DropdownMenuSeparatorProps & { class?: HTMLAttributes['class'] }>()
-
-const forwarded = useForwardProps(props)
-</script>
-
-<template>
-  <DropdownMenuSeparator
-    v-bind="forwarded"
-    :class="cn('-mx-1 my-1 h-px bg-muted', props.class)"
-  />
-</template>

frontend/components/ui/dropdown-menu/index.ts

@@ -2,4 +2,3 @@ export { default as DropdownMenu } from './DropdownMenu.vue'
 export { default as DropdownMenuTrigger } from './DropdownMenuTrigger.vue'
 export { default as DropdownMenuContent } from './DropdownMenuContent.vue'
 export { default as DropdownMenuItem } from './DropdownMenuItem.vue'
-export { default as DropdownMenuSeparator } from './DropdownMenuSeparator.vue'

frontend/components/views/DetailView.vue

@@ -5,8 +5,6 @@ import { Button } from '@/components/ui/button'
 import { Separator } from '@/components/ui/separator'
 import FieldRenderer from '@/components/fields/FieldRenderer.vue'
 import RelatedList from '@/components/RelatedList.vue'
-import RecordCommentsPanel from '@/components/knowledge/RecordCommentsPanel.vue'
-import SemanticLinksPanel from '@/components/knowledge/SemanticLinksPanel.vue'
 import { DetailViewConfig, ViewMode, FieldSection, FieldConfig, RelatedListConfig } from '@/types/field-types'
 import { Edit, Trash2, ArrowLeft } from 'lucide-vue-next'
 import {
@@ -169,18 +167,6 @@ const getFieldsBySection = (section: FieldSection) => {
         @create="(objectApiName, parentId) => emit('createRelated', objectApiName, parentId)"
       />
     </div>
-
-    <!-- Knowledge Panels -->
-    <div v-if="data?.id && config?.objectApiName" class="space-y-6">
-      <RecordCommentsPanel
-        :object-api-name="config.objectApiName"
-        :record-id="data.id"
-      />
-      <SemanticLinksPanel
-        :object-api-name="config.objectApiName"
-        :record-id="data.id"
-      />
-    </div>
   </div>
 </template>
 

frontend/components/views/DetailViewEnhanced.vue

@@ -7,8 +7,6 @@ import FieldRenderer from '@/components/fields/FieldRenderer.vue'
 import PageLayoutRenderer from '@/components/PageLayoutRenderer.vue'
 import RelatedList from '@/components/RelatedList.vue'
 import RecordSharing from '@/components/RecordSharing.vue'
-import RecordCommentsPanel from '@/components/knowledge/RecordCommentsPanel.vue'
-import SemanticLinksPanel from '@/components/knowledge/SemanticLinksPanel.vue'
 import { DetailViewConfig, ViewMode, FieldSection, FieldConfig, RelatedListConfig } from '@/types/field-types'
 import { Edit, Trash2, ArrowLeft } from 'lucide-vue-next'
 import {
@@ -172,9 +170,6 @@ const visibleRelatedLists = computed<RelatedListConfig[]>(() => {
         <TabsTrigger v-if="showSharing && data.id" value="sharing">
           Sharing
         </TabsTrigger>
-        <TabsTrigger v-if="data.id && config.objectApiName" value="knowledge">
-          Knowledge
-        </TabsTrigger>
       </TabsList>
 
       <!-- Details Tab -->
@@ -282,20 +277,6 @@ const visibleRelatedLists = computed<RelatedListConfig[]>(() => {
           </CardContent>
         </Card>
       </TabsContent>
-
-      <!-- Knowledge Tab -->
-      <TabsContent value="knowledge" class="space-y-6">
-        <RecordCommentsPanel
-          v-if="data.id && config.objectApiName"
-          :object-api-name="config.objectApiName"
-          :record-id="data.id"
-        />
-        <SemanticLinksPanel
-          v-if="data.id && config.objectApiName"
-          :object-api-name="config.objectApiName"
-          :record-id="data.id"
-        />
-      </TabsContent>
     </Tabs>
   </div>
 </template>

frontend/components/views/ListView.vue

@@ -1,9 +1,5 @@
 <script setup lang="ts">
 import { ref, computed, watch } from 'vue'
-import type { CellValueChangedEvent, ColDef, GridApi, GridReadyEvent } from 'ag-grid-community'
-import { AgGridVue } from 'ag-grid-vue3'
-import 'ag-grid-community/styles/ag-grid.css'
-import 'ag-grid-community/styles/ag-theme-alpine.css'
 import {
   Table,
   TableBody,
@@ -17,17 +13,9 @@ import { Input } from '@/components/ui/input'
 import { Badge } from '@/components/ui/badge'
 import { Checkbox } from '@/components/ui/checkbox'
 import { Select, SelectContent, SelectItem, SelectTrigger, SelectValue } from '@/components/ui/select'
-import {
-  DropdownMenu,
-  DropdownMenuContent,
-  DropdownMenuItem,
-  DropdownMenuSeparator,
-  DropdownMenuTrigger,
-} from '@/components/ui/dropdown-menu'
 import FieldRenderer from '@/components/fields/FieldRenderer.vue'
-import { ListViewConfig, ViewMode, FieldType, FieldConfig } from '@/types/field-types'
-import { ChevronDown, ChevronUp, Search, Plus, Download, Trash2, Edit, Bookmark, BookmarkPlus, Settings2 } from 'lucide-vue-next'
-import type { SavedView } from '@/composables/useSavedViews'
+import { ListViewConfig, ViewMode, FieldType } from '@/types/field-types'
+import { ChevronDown, ChevronUp, Search, Plus, Download, Trash2, Edit } from 'lucide-vue-next'
 
 interface Props {
   config: ListViewConfig
@@ -37,14 +25,6 @@ interface Props {
   baseUrl?: string
   totalCount?: number
   searchSummary?: string
-  draftEdits?: Record<string, Record<string, any>>
-  cellErrors?: Record<string, Record<string, string | boolean>>
-  savingDrafts?: boolean
-  // Saved views
-  savedViews?: SavedView[]
-  activeViewId?: string | null
-  currentSearchPlan?: { strategy: string; filters: any[]; sort: any; explanation: string } | null
-  savingView?: boolean
 }
 
 const props = withDefaults(defineProps<Props>(), {
@@ -53,13 +33,6 @@ const props = withDefaults(defineProps<Props>(), {
   selectable: false,
   baseUrl: '/runtime/objects',
   searchSummary: '',
-  draftEdits: () => ({}),
-  cellErrors: () => ({}),
-  savingDrafts: false,
-  savedViews: () => [],
-  activeViewId: null,
-  currentSearchPlan: null,
-  savingView: false,
 })
 
 const emit = defineEmits<{
@@ -74,14 +47,6 @@ const emit = defineEmits<{
   'refresh': []
   'page-change': [page: number, pageSize: number]
   'load-more': [page: number, pageSize: number]
-  'view-change': [mode: 'list' | 'spreadsheet']
-  'cell-edit': [payload: { row: any; field: FieldConfig; newValue: any; oldValue: any }]
-  'save-drafts': []
-  'discard-drafts': []
-  // Saved views
-  'apply-view': [view: SavedView]
-  'save-view': []
-  'open-view-manager': []
 }>()
 
 // State
@@ -92,8 +57,6 @@ const sortField = ref<string>('')
 const sortDirection = ref<'asc' | 'desc'>('asc')
 const currentPage = ref(1)
 const bulkAction = ref('delete')
-const viewMode = ref<'list' | 'spreadsheet'>('list')
-const gridApi = ref<GridApi | null>(null)
 
 // Computed
 const visibleFields = computed(() => 
@@ -124,7 +87,7 @@ const paginatedData = computed(() => {
 })
 const pageStart = computed(() => (props.data.length === 0 ? 0 : startIndex.value + 1))
 const pageEnd = computed(() => Math.min(startIndex.value + paginatedData.value.length, totalRecords.value))
-const showPagination = computed(() => viewMode.value === 'list' && totalRecords.value > pageSize.value)
+const showPagination = computed(() => totalRecords.value > pageSize.value)
 const canGoPrev = computed(() => currentPage.value > 1)
 const canGoNext = computed(() => currentPage.value < availablePages.value)
 const showLoadMore = computed(() => (
@@ -132,8 +95,6 @@ const showLoadMore = computed(() => (
   Boolean(props.totalCount) &&
   props.data.length < totalRecords.value
 ))
-const draftRowCount = computed(() => Object.keys(props.draftEdits).length)
-const draftCellCount = computed(() => Object.values(props.draftEdits).reduce((sum, row) => sum + Object.keys(row).length, 0))
 
 const allSelected = computed({
   get: () => props.data.length > 0 && selectedRowIds.value.length === props.data.length,
@@ -198,154 +159,6 @@ const handleBulkAction = () => {
   emit('action', bulkAction.value, getSelectedRows())
 }
 
-const isEditableField = (field: FieldConfig) =>
-  field.showOnEdit !== false &&
-  !field.isReadOnly &&
-  ![FieldType.BELONGS_TO, FieldType.HAS_MANY, FieldType.MANY_TO_MANY].includes(field.type)
-
-const getRelationPropertyName = (apiName: string) => apiName.replace(/Id$/, '').toLowerCase()
-
-const formatFieldValue = (field: FieldConfig, value: any, record?: any) => {
-  if (value === null || value === undefined) return ''
-  switch (field.type) {
-    case FieldType.BELONGS_TO: {
-      const relationPropertyName = getRelationPropertyName(field.apiName)
-      const relatedObject = record?.[relationPropertyName]
-      if (relatedObject && typeof relatedObject === 'object') {
-        const displayField = field.relationDisplayField || 'name'
-        return relatedObject[displayField] || relatedObject.id || value
-      }
-      return value
-    }
-    case FieldType.DATE: {
-      const date = value instanceof Date ? value : new Date(value)
-      return Number.isNaN(date.getTime())
-        ? String(value)
-        : date.toLocaleDateString(undefined, { year: 'numeric', month: '2-digit', day: '2-digit' })
-    }
-    case FieldType.DATETIME: {
-      const date = value instanceof Date ? value : new Date(value)
-      return Number.isNaN(date.getTime())
-        ? String(value)
-        : date.toLocaleString(undefined, {
-            year: 'numeric',
-            month: '2-digit',
-            day: '2-digit',
-            hour: '2-digit',
-            minute: '2-digit',
-            second: '2-digit',
-            hour12: false,
-          })
-    }
-    case FieldType.BOOLEAN:
-      return value ? 'Yes' : 'No'
-    case FieldType.CURRENCY:
-      return `${field.prefix || '$'}${Number(value).toFixed(2)}${field.suffix || ''}`
-    case FieldType.SELECT: {
-      const option = field.options?.find(opt => opt.value === value)
-      return option?.label || value
-    }
-    case FieldType.MULTI_SELECT:
-      return Array.isArray(value)
-        ? value
-            .map(v => field.options?.find(opt => opt.value === v)?.label || v)
-            .join(', ')
-        : ''
-    default:
-      return String(value)
-  }
-}
-
-const hasOwnProperty = (target: Record<string, any> | undefined, key: string) =>
-  !!target && Object.prototype.hasOwnProperty.call(target, key)
-
-const isDraftCell = (params: any) => {
-  const rowId = normalizeId(params?.data?.id)
-  const field = String(params?.colDef?.field || '')
-  return hasOwnProperty(props.draftEdits[rowId], field)
-}
-
-const isErrorCell = (params: any) => {
-  const rowId = normalizeId(params?.data?.id)
-  const field = String(params?.colDef?.field || '')
-  return hasOwnProperty(props.cellErrors[rowId], field)
-}
-
-const getCellClasses = (params: any) => {
-  const classes: string[] = []
-  if (isDraftCell(params)) classes.push('cell-draft')
-  if (isErrorCell(params)) classes.push('cell-error')
-  return classes
-}
-
-const getCellStyle = (params: any) => {
-  const isDraft = isDraftCell(params)
-  const isError = isErrorCell(params)
-  if (!isDraft && !isError) return null
-  const style: Record<string, string> = {}
-  if (isDraft) {
-    style.backgroundColor = 'hsl(var(--accent) / 0.45)'
-    style.outline = '2px solid hsl(var(--accent))'
-    style.outlineOffset = '-2px'
-  }
-  if (isError) {
-    style.backgroundColor = 'hsl(var(--destructive) / 0.28)'
-    style.outline = '2px solid hsl(var(--destructive))'
-    style.outlineOffset = '-2px'
-  }
-  return style
-}
-
-const columnDefs = computed<ColDef[]>(() =>
-  visibleFields.value.map(field => ({
-    field: field.apiName,
-    headerName: field.label,
-    sortable: field.sortable !== false,
-    editable: isEditableField(field),
-    valueFormatter: params => formatFieldValue(field, params.value, params.data),
-    cellClass: params => getCellClasses(params),
-    cellStyle: params => getCellStyle(params),
-    cellEditor:
-      field.type === FieldType.SELECT
-        ? 'agSelectCellEditor'
-        : field.type === FieldType.MULTI_SELECT
-          ? 'agTextCellEditor'
-          : field.type === FieldType.NUMBER || field.type === FieldType.CURRENCY
-            ? 'agTextCellEditor'
-            : undefined,
-    cellEditorParams:
-      field.type === FieldType.SELECT
-        ? { values: (field.options || []).map(opt => opt.value) }
-        : undefined,
-    valueParser:
-      field.type === FieldType.NUMBER || field.type === FieldType.CURRENCY
-        ? params => (params.newValue === '' ? null : Number(params.newValue))
-        : undefined,
-    flex: 1,
-    minWidth: 160,
-  }))
-)
-
-const defaultColDef: ColDef = {
-  resizable: true,
-  sortable: true,
-}
-
-const handleCellValueChanged = (event: CellValueChangedEvent) => {
-  const field = visibleFields.value.find(item => item.apiName === event.colDef.field)
-  if (!field || event.newValue === event.oldValue) return
-  emit('cell-edit', {
-    row: event.data,
-    field,
-    newValue: event.newValue,
-    oldValue: event.oldValue,
-  })
-}
-
-const handleGridReady = (event: GridReadyEvent) => {
-  gridApi.value = event.api
-}
-
 const goToPage = (page: number) => {
   const nextPage = Math.min(Math.max(page, 1), availablePages.value)
   if (nextPage !== currentPage.value) {
@@ -380,23 +193,6 @@ watch(
   },
   { deep: true }
 )
-
-watch(
-  () => viewMode.value,
-  (mode) => {
-    emit('view-change', mode)
-  }
-)
-
-watch(
-  () => [props.draftEdits, props.cellErrors],
-  () => {
-    if (gridApi.value) {
-      gridApi.value.refreshCells({ force: true })
-    }
-  },
-  { deep: true }
-)
 </script>
 
 <template>
@@ -420,95 +216,6 @@ watch(
       </div>
 
       <div class="flex items-center gap-2">
-        <!-- Saved Views dropdown + cog -->
-        <div class="flex items-center gap-1">
-          <DropdownMenu>
-            <DropdownMenuTrigger as-child>
-              <Button variant="outline" size="sm" class="gap-2">
-                <Bookmark class="h-4 w-4" />
-                <span class="max-w-[120px] truncate">
-                  {{ savedViews.find(v => v.id === activeViewId)?.name || 'Views' }}
-                </span>
-                <ChevronDown class="h-3 w-3 opacity-60" />
-              </Button>
-            </DropdownMenuTrigger>
-            <DropdownMenuContent align="start" class="w-56">
-              <DropdownMenuItem
-                v-if="savedViews.length === 0"
-                disabled
-                class="text-muted-foreground"
-              >
-                No saved views yet
-              </DropdownMenuItem>
-              <DropdownMenuItem
-                v-for="view in savedViews"
-                :key="view.id"
-                :class="{ 'font-medium': view.id === activeViewId }"
-                @click="emit('apply-view', view)"
-              >
-                <span class="flex-1 truncate">{{ view.name }}</span>
-                <Badge v-if="view.isShared" variant="secondary" class="ml-2 text-[10px] px-1.5 py-0">Shared</Badge>
-              </DropdownMenuItem>
-              <DropdownMenuSeparator v-if="savedViews.length > 0" />
-              <DropdownMenuItem @click="emit('open-view-manager')">
-                Manage views…
-              </DropdownMenuItem>
-            </DropdownMenuContent>
-          </DropdownMenu>
-
-          <Button
-            variant="ghost"
-            size="icon"
-            class="h-8 w-8"
-            title="Manage saved views"
-            @click="emit('open-view-manager')"
-          >
-            <Settings2 class="h-4 w-4" />
-          </Button>
-        </div>
-
-        <!-- Save current search as a view (only for query strategy) -->
-        <Button
-          v-if="currentSearchPlan?.strategy === 'query'"
-          variant="outline"
-          size="sm"
-          :disabled="savingView"
-          class="gap-2"
-          @click="emit('save-view')"
-        >
-          <BookmarkPlus class="h-4 w-4" />
-          Save view
-        </Button>
-
-        <Select v-model="viewMode">
-          <SelectTrigger class="h-8 w-[180px]">
-            <SelectValue placeholder="Select view" />
-          </SelectTrigger>
-          <SelectContent>
-            <SelectItem value="list">List view</SelectItem>
-            <SelectItem value="spreadsheet">Spreadsheet view</SelectItem>
-          </SelectContent>
-        </Select>
-        <template v-if="viewMode === 'spreadsheet'">
-          <Badge v-if="draftRowCount > 0" variant="secondary" class="px-3 py-1">
-            {{ draftCellCount }} change{{ draftCellCount === 1 ? '' : 's' }}
-          </Badge>
-          <Button
-            variant="outline"
-            size="sm"
-            :disabled="draftRowCount === 0 || savingDrafts"
-            @click="emit('discard-drafts')"
-          >
-            Discard changes
-          </Button>
-          <Button
-            size="sm"
-            :disabled="draftRowCount === 0 || savingDrafts"
-            @click="emit('save-drafts')"
-          >
-            Save changes ({{ draftRowCount }})
-          </Button>
-        </template>
         <!-- Bulk Actions -->
         <template v-if="selectedRowIds.length > 0">
           <Badge variant="secondary" class="px-3 py-1">
@@ -557,7 +264,7 @@ watch(
 
     <!-- Table -->
     <div class="border rounded-lg">
-      <Table v-if="viewMode === 'list'">
+      <Table>
         <TableHeader>
           <TableRow>
             <TableHead v-if="selectable" class="w-12">
@@ -631,19 +338,6 @@ watch(
           </TableRow>
         </TableBody>
       </Table>
-      <div v-else class="ag-theme-alpine">
-        <AgGridVue
-          :row-data="data"
-          :column-defs="columnDefs"
-          :default-col-def="defaultColDef"
-          dom-layout="autoHeight"
-          row-selection="multiple"
-          suppress-row-click-selection
-          single-click-edit
-          @cell-value-changed="handleCellValueChanged"
-          @grid-ready="handleGridReady"
-        />
-      </div>
     </div>
 
     <div v-if="showPagination" class="flex flex-wrap items-center justify-between gap-3 text-sm text-muted-foreground">
@@ -681,5 +375,4 @@ watch(
 .list-view :deep(input) {
   background-color: hsl(var(--background));
 }
-
 </style>

frontend/composables/useApi.ts

@@ -1,25 +1,40 @@
 export const useApi = () => {
+  const config = useRuntimeConfig()
   const router = useRouter()
   const { toast } = useToast()
   const { isLoggedIn, logout } = useAuth()
 
-  /**
-   * API calls now go through the Nitro BFF proxy at /api/*
-   * The proxy handles:
-   * - Auth token injection from HTTP-only cookies
-   * - Tenant subdomain extraction and forwarding
-   * - Forwarding requests to the NestJS backend
-   */
+  // Use current domain for API calls (same subdomain routing)
   const getApiBaseUrl = () => {
-    // All API calls go through Nitro proxy - works for both SSR and client
-    return ''
+    if (import.meta.client) {
+      // In browser, use current hostname but with port 3000 for API
+      const currentHost = window.location.hostname
+      const protocol = window.location.protocol
+      //return `${protocol}//${currentHost}:3000`
+      return `${protocol}//${currentHost}`
+    }
+    // Fallback for SSR
+    return config.public.apiBaseUrl
   }
 
   const getHeaders = () => {
-    // Headers are now minimal - auth and tenant are handled by the Nitro proxy
     const headers: Record<string, string> = {
       'Content-Type': 'application/json',
     }
+
+    // Add tenant ID from localStorage or state
+    if (import.meta.client) {
+      const tenantId = localStorage.getItem('tenantId')
+      if (tenantId) {
+        headers['x-tenant-id'] = tenantId
+      }
+
+      const token = localStorage.getItem('token')
+      if (token) {
+        headers['Authorization'] = `Bearer ${token}`
+      }
+    }
+
     return headers
   }
 

frontend/composables/useAuth.ts

@@ -1,131 +1,61 @@
-/**
- * Authentication composable using BFF (Backend for Frontend) pattern
- * Auth tokens are stored in HTTP-only cookies managed by Nitro server
- * Tenant context is stored in a readable cookie for client-side access
- */
 export const useAuth = () => {
+  const tokenCookie = useCookie('token')
   const authMessageCookie = useCookie('authMessage')
-  const tenantCookie = useCookie('routebox_tenant')
   const router = useRouter()
+  const config = useRuntimeConfig()
   
-  // Reactive user state - populated from /api/auth/me
-  const user = useState<any>('auth_user', () => null)
-  const isAuthenticated = useState<boolean>('auth_is_authenticated', () => false)
-  const isLoading = useState<boolean>('auth_is_loading', () => false)
-
-  /**
-   * Check if user is logged in
-   * Uses server-side session validation via /api/auth/me
-   */
   const isLoggedIn = () => {
-    return isAuthenticated.value
+    if (!import.meta.client) return false
+    const token = localStorage.getItem('token')
+    const tenantId = localStorage.getItem('tenantId')
+    return !!(token && tenantId)
   }
 
-  /**
-   * Login with email and password
-   * Calls the Nitro BFF login endpoint which sets HTTP-only cookies
-   */
-  const login = async (email: string, password: string) => {
-    isLoading.value = true
-    
-    try {
-      const response = await $fetch('/api/auth/login', {
-        method: 'POST',
-        body: { email, password },
-      })
-      
-      if (response.success) {
-        user.value = response.user
-        isAuthenticated.value = true
-        return { success: true, user: response.user }
-      }
-      
-      return { success: false, error: 'Login failed' }
-    } catch (error: any) {
-      const message = error.data?.message || error.message || 'Login failed'
-      return { success: false, error: message }
-    } finally {
-      isLoading.value = false
-    }
-  }
-
-  /**
-   * Logout user
-   * Calls the Nitro BFF logout endpoint which clears HTTP-only cookies
-   */
   const logout = async () => {
-    try {
-      await $fetch('/api/auth/logout', {
-        method: 'POST',
-      })
-    } catch (error) {
-      console.error('Logout error:', error)
-    }
-    
-    // Clear local state
-    user.value = null
-    isAuthenticated.value = false
-    
-    // Set flash message for login page
-    authMessageCookie.value = 'Logged out successfully'
-    
-    // Redirect to login page
-    router.push('/login')
-  }
-
-  /**
-   * Check current authentication status
-   * Validates session with backend via Nitro BFF
-   */
-  const checkAuth = async () => {
-    isLoading.value = true
-    
-    try {
-      const response = await $fetch('/api/auth/me', {
-        method: 'GET',
-      })
-      
-      if (response.authenticated && response.user) {
-        user.value = response.user
-        isAuthenticated.value = true
-        return true
+    if (import.meta.client) {
+      // Call backend logout endpoint
+      try {
+        const token = localStorage.getItem('token')
+        const tenantId = localStorage.getItem('tenantId')
+        
+        if (token) {
+          await fetch(`${config.public.apiBaseUrl}/api/auth/logout`, {
+            method: 'POST',
+            headers: {
+              'Authorization': `Bearer ${token}`,
+              ...(tenantId && { 'x-tenant-id': tenantId }),
+            },
+          })
+        }
+      } catch (error) {
+        console.error('Logout error:', error)
       }
-    } catch (error) {
-      // Session invalid or expired
-      user.value = null
-      isAuthenticated.value = false
-    } finally {
-      isLoading.value = false
+      
+      // Clear local storage
+      localStorage.removeItem('token')
+      localStorage.removeItem('tenantId')
+      localStorage.removeItem('user')
+      
+      // Clear cookie for server-side check
+      tokenCookie.value = null
+      
+      // Set flash message for login page
+      authMessageCookie.value = 'Logged out successfully'
+      
+      // Redirect to login page
+      router.push('/login')
     }
-    
-    return false
   }
 
-  /**
-   * Get current user
-   */
   const getUser = () => {
-    return user.value
-  }
-
-  /**
-   * Get current tenant ID from cookie
-   */
-  const getTenantId = () => {
-    return tenantCookie.value
+    if (!import.meta.client) return null
+    const userStr = localStorage.getItem('user')
+    return userStr ? JSON.parse(userStr) : null
   }
 
   return {
-    // State
-    user,
-    isAuthenticated,
-    isLoading,
-    // Methods
     isLoggedIn,
-    login,
     logout,
-    checkAuth,
     getUser,
-    getTenantId,
   }
 }

frontend/composables/useSavedViews.ts

@@ -1,107 +0,0 @@
-export interface SavedViewFilter {
-  field: string
-  operator: string
-  value?: any
-  values?: any[]
-  from?: string
-  to?: string
-}
-
-export interface SavedViewSort {
-  field: string
-  direction: 'asc' | 'desc'
-}
-
-export interface SavedView {
-  id: string
-  name: string
-  objectApiName: string
-  userId: string
-  isOwner: boolean
-  isShared: boolean
-  strategy: 'query'
-  filters: SavedViewFilter[]
-  sort: SavedViewSort | null
-  description: string | null
-  createdAt: string
-  updatedAt: string
-}
-
-export interface CreateSavedViewPayload {
-  name: string
-  objectApiName: string
-  filters: SavedViewFilter[]
-  sort?: SavedViewSort | null
-  description?: string
-}
-
-export interface UpdateSavedViewPayload {
-  name?: string
-  filters?: SavedViewFilter[]
-  sort?: SavedViewSort | null
-  description?: string
-}
-
-export function useSavedViews() {
-  const { api } = useApi()
-
-  const savedViews = ref<SavedView[]>([])
-  const loading = ref(false)
-
-  async function fetchSavedViews(objectApiName: string) {
-    loading.value = true
-    try {
-      const data = await api.get(`/saved-views/${objectApiName}`)
-      savedViews.value = Array.isArray(data) ? data : []
-    } catch (e) {
-      console.error('Failed to fetch saved views', e)
-      savedViews.value = []
-    } finally {
-      loading.value = false
-    }
-  }
-
-  async function createSavedView(payload: CreateSavedViewPayload): Promise<SavedView> {
-    const created = await api.post('/saved-views', payload)
-    savedViews.value = [...savedViews.value, created]
-    return created
-  }
-
-  async function updateSavedView(id: string, payload: UpdateSavedViewPayload): Promise<SavedView> {
-    const updated = await api.patch(`/saved-views/${id}`, payload)
-    savedViews.value = savedViews.value.map(v => (v.id === id ? updated : v))
-    return updated
-  }
-
-  async function deleteSavedView(id: string) {
-    await api.delete(`/saved-views/${id}`)
-    savedViews.value = savedViews.value.filter(v => v.id !== id)
-  }
-
-  async function suggestViewName(
-    objectLabel: string,
-    filters: SavedViewFilter[],
-    explanation?: string,
-  ): Promise<string> {
-    try {
-      const result = await api.post('/ai/suggest-view-name', {
-        objectLabel,
-        filters,
-        explanation,
-      })
-      return result?.suggestedName || `${objectLabel} View`
-    } catch {
-      return `${objectLabel} View`
-    }
-  }
-
-  return {
-    savedViews,
-    loading,
-    fetchSavedViews,
-    createSavedView,
-    updateSavedView,
-    deleteSavedView,
-    suggestViewName,
-  }
-}

frontend/composables/useSoftphone.ts

@@ -1,4 +1,4 @@
-import { ref, computed, onMounted, onUnmounted, shallowRef, watch } from 'vue';
+import { ref, computed, onMounted, onUnmounted, shallowRef } from 'vue';
 import { io, Socket } from 'socket.io-client';
 import { Device, Call as TwilioCall } from '@twilio/voice-sdk';
 import { useAuth } from './useAuth';
@@ -44,6 +44,17 @@ const volume = ref(100);
 export function useSoftphone() {
   const auth = useAuth();
 
+  // Get token and tenantId from localStorage
+  const getToken = () => {
+    if (typeof window === 'undefined') return null;
+    return localStorage.getItem('token');
+  };
+
+  const getTenantId = () => {
+    if (typeof window === 'undefined') return null;
+    return localStorage.getItem('tenantId');
+  };
+
   // Computed properties
   const isInCall = computed(() => currentCall.value !== null);
   const hasIncomingCall = computed(() => incomingCall.value !== null);
@@ -82,12 +93,6 @@ export function useSoftphone() {
    * Initialize Twilio Device
    */
   const initializeTwilioDevice = async () => {
-    // Prevent re-initialization if device already exists and is registered
-    if (twilioDevice.value) {
-      console.log('Twilio Device already exists, skipping initialization');
-      return;
-    }
-
     try {
       // First, explicitly request microphone permission
       const hasPermission = await requestMicrophonePermission();
@@ -102,14 +107,12 @@ export function useSoftphone() {
       // Log the token payload to see what identity is being used
       try {
         const tokenPayload = JSON.parse(atob(token.split('.')[1]));
-        console.log('📱 Twilio Device identity:', tokenPayload.grants?.identity || tokenPayload.sub);
       } catch (e) {
         console.log('Could not parse token payload');
       }
 
-      console.log('📱 Creating new Twilio Device...');
       twilioDevice.value = new Device(token, {
-        logLevel: 1, // Reduce log level (1 = errors only, 3 = debug)
+        logLevel: 3,
         codecPreferences: ['opus', 'pcmu'],
         enableImprovedSignalingErrorPrecision: true,
         edge: 'ashburn',
@@ -117,12 +120,10 @@ export function useSoftphone() {
 
       // Device events
       twilioDevice.value.on('registered', () => {
-        console.log('✅ Twilio Device registered successfully');
         toast.success('Softphone ready');
       });
 
       twilioDevice.value.on('unregistered', () => {
-        console.log('📱 Twilio Device unregistered');
       });
 
       twilioDevice.value.on('error', (error) => {
@@ -131,11 +132,6 @@ export function useSoftphone() {
       });
 
       twilioDevice.value.on('incoming', (call: TwilioCall) => {
-        console.log('📞 Twilio Device incoming call event!', {
-          callSid: call.parameters.CallSid,
-          from: call.parameters.From,
-          to: call.parameters.To,
-        });
         twilioCall.value = call;
 
         // Update state
@@ -214,54 +210,35 @@ export function useSoftphone() {
   /**
    * Initialize WebSocket connection
    */
-  const connect = async () => {
-    // Guard against multiple connection attempts
-    if (socket.value) {
-      console.log('Softphone: Socket already exists, skipping connection');
+  const connect = () => {
+    const token = getToken();
+    
+    if (socket.value?.connected || !token) {
       return;
     }
 
-    // Check if user is authenticated
-    if (!auth.isAuthenticated.value) {
-      // Try to verify authentication first
-      const isValid = await auth.checkAuth();
-      if (!isValid) {
-        console.log('Softphone: User not authenticated, skipping connection');
-        return;
+    // Use same pattern as useApi to preserve subdomain for multi-tenant
+    const getBackendUrl = () => {
+      if (typeof window !== 'undefined') {
+        const currentHost = window.location.hostname;
+        const protocol = window.location.protocol;
+        return `${protocol}//${currentHost}`;
       }
-    }
+      return 'http://localhost:3000';
+    };
 
-    try {
-      // Get WebSocket token from BFF (this retrieves the token from HTTP-only cookie server-side)
-      const wsAuth = await $fetch('/api/auth/ws-token');
-      
-      if (!wsAuth.token) {
-        console.log('Softphone: No WebSocket token available');
-        return;
-      }
-
-      // Use same pattern as useApi to preserve subdomain for multi-tenant
-      const getBackendUrl = () => {
-        if (typeof window !== 'undefined') {
-          const currentHost = window.location.hostname;
-          const protocol = window.location.protocol;
-          return `${protocol}//${currentHost}`;
-        }
-        return 'http://localhost:3000';
-      };
-
-      // Connect to /voice namespace with proper auth header
-      socket.value = io(`${getBackendUrl()}/voice`, {
-        auth: {
-          token: wsAuth.token,
-        },
-        transports: ['websocket', 'polling'],
-        reconnection: true,
-        reconnectionDelay: 1000,
-        reconnectionDelayMax: 5000,
-        reconnectionAttempts: 5,
-        query: {}, // Explicitly set empty query to prevent token leaking
-      });
+    // Connect to /voice namespace with proper auth header
+    socket.value = io(`${getBackendUrl()}/voice`, {
+      auth: {
+        token: token,
+      },
+      transports: ['websocket', 'polling'],
+      reconnection: true,
+      reconnectionDelay: 1000,
+      reconnectionDelayMax: 5000,
+      reconnectionAttempts: 5,
+      query: {}, // Explicitly set empty query to prevent token leaking
+    });
 
     // Connection events
     socket.value.on('connect', () => {
@@ -302,10 +279,6 @@ export function useSoftphone() {
     socket.value.on('ai:action', handleAiAction);
 
     isInitialized.value = true;
-    } catch (error: any) {
-      console.error('Softphone: Failed to connect:', error);
-      toast.error('Failed to initialize voice service');
-    }
   };
 
   /**
@@ -596,25 +569,14 @@ export function useSoftphone() {
     }
   };
 
-  // Only set up auto-connect and watchers once (not for every component that uses this composable)
-  // Use a module-level flag to track if watchers are already set up
-  if (process.client && !isInitialized.value && !socket.value) {
-    // Auto-connect if authenticated
-    if (auth.isAuthenticated.value) {
+  // Auto-connect on mount if token is available
+  onMounted(() => {
+    if (getToken() && !isInitialized.value) {
       connect();
     }
+  });
 
-    // Watch for authentication changes to connect/disconnect
-    watch(() => auth.isAuthenticated.value, async (isAuth) => {
-      if (isAuth && !isInitialized.value && !socket.value) {
-        await connect();
-      } else if (!isAuth && isInitialized.value) {
-        disconnect();
-      }
-    });
-  }
-
-  // Cleanup on unmount - only stop ringtone, don't disconnect shared socket
+  // Cleanup on unmount
   onUnmounted(() => {
     stopRingtone();
   });

frontend/middleware/auth.global.ts

@@ -1,4 +1,4 @@
-export default defineNuxtRouteMiddleware(async (to, from) => {
+export default defineNuxtRouteMiddleware((to, from) => {
   // Allow pages to opt-out of auth with definePageMeta({ auth: false })
   if (to.meta.auth === false) {
     return
@@ -11,45 +11,28 @@ export default defineNuxtRouteMiddleware(async (to, from) => {
     return
   }
 
+  const token = useCookie('token')
   const authMessage = useCookie('authMessage')
-  // Check for tenant cookie (set alongside session cookie on login)
-  const tenantCookie = useCookie('routebox_tenant')
-  // Also check for session cookie (HTTP-only, but readable in SSR context)
-  const sessionCookie = useCookie('routebox_session')
   
   // Routes that don't need a toast message (user knows they need to login)
   const silentRoutes = ['/']
-
-  // On client side, check the reactive auth state
-  if (import.meta.client) {
-    const { isAuthenticated, checkAuth } = useAuth()
-    
-    // If we already know we're authenticated, allow
-    if (isAuthenticated.value) {
-      return
-    }
-    
-    // If we have a tenant cookie, try to validate the session
-    if (tenantCookie.value) {
-      const isValid = await checkAuth()
-      if (isValid) {
-        return
-      }
-    }
-    
-    // Not authenticated
+  
+  // Check token cookie (works on both server and client)
+  if (!token.value) {
     if (!silentRoutes.includes(to.path)) {
       authMessage.value = 'Please login to access this page'
     }
     return navigateTo('/login')
   }
   
-  // Server-side: check for both session and tenant cookies
-  // The session cookie is HTTP-only but can be read in SSR context
-  if (!sessionCookie.value || !tenantCookie.value) {
-    if (!silentRoutes.includes(to.path)) {
-      authMessage.value = 'Please login to access this page'
+  // On client side, also verify localStorage is in sync
+  if (import.meta.client) {
+    const { isLoggedIn } = useAuth()
+    if (!isLoggedIn()) {
+      if (!silentRoutes.includes(to.path)) {
+        authMessage.value = 'Please login to access this page'
+      }
+      return navigateTo('/login')
     }
-    return navigateTo('/login')
   }
 })

frontend/nuxt.config.ts

@@ -24,9 +24,9 @@ export default defineNuxtConfig({
   },
 
   runtimeConfig: {
-    // Server-only config (not exposed to client)
-    // Used by Nitro BFF to proxy requests to the NestJS backend
-    backendUrl: process.env.BACKEND_URL || 'http://localhost:3000',
+    public: {
+      apiBaseUrl: process.env.NUXT_PUBLIC_API_BASE_URL || 'http://localhost:3000',
+    },
   },
 
   app: {

frontend/package-lock.json

@@ -13,8 +13,6 @@
         "@nuxtjs/tailwindcss": "^6.11.4",
         "@twilio/voice-sdk": "^2.11.2",
         "@vueuse/core": "^10.11.1",
-        "ag-grid-community": "^32.3.4",
-        "ag-grid-vue3": "^32.3.4",
         "class-variance-authority": "^0.7.0",
         "clsx": "^2.1.0",
         "gridstack": "^12.4.1",
@@ -4978,31 +4976,6 @@
         "acorn": "^6.0.0 || ^7.0.0 || ^8.0.0"
       }
     },
-    "node_modules/ag-charts-types": {
-      "version": "10.3.9",
-      "resolved": "https://registry.npmjs.org/ag-charts-types/-/ag-charts-types-10.3.9.tgz",
-      "integrity": "sha512-drcRiJVencliC8LnRwk4MmeQDNNBg5GzmOoLFihO3/k0CUK0VF/N+2nc7iFozwaNG0btSB9vAhYuJLjqHMtRrQ==",
-      "license": "MIT"
-    },
-    "node_modules/ag-grid-community": {
-      "version": "32.3.9",
-      "resolved": "https://registry.npmjs.org/ag-grid-community/-/ag-grid-community-32.3.9.tgz",
-      "integrity": "sha512-l07SB0mCbGPkC1R8rQQFgBtI5+1FoXBi3RUk1+dHKV/UPeorMEFAzCokcsOhz0qwcWCPrHauUsbRa1SIxfVEJQ==",
-      "license": "MIT",
-      "dependencies": {
-        "ag-charts-types": "10.3.9"
-      }
-    },
-    "node_modules/ag-grid-vue3": {
-      "version": "32.3.9",
-      "resolved": "https://registry.npmjs.org/ag-grid-vue3/-/ag-grid-vue3-32.3.9.tgz",
-      "integrity": "sha512-86Xynbfg8bq/tGW0Yfl2O8HSUgT7nDtNzioMs4r8hNfPiqOfKUUWrTveP5S4Acs8Astr495ZdKKFDIcQVLx3Yg==",
-      "license": "MIT",
-      "dependencies": {
-        "ag-grid-community": "32.3.9",
-        "vue": "^3.0.0"
-      }
-    },
     "node_modules/agent-base": {
       "version": "7.1.4",
       "resolved": "https://registry.npmjs.org/agent-base/-/agent-base-7.1.4.tgz",

frontend/package.json

@@ -19,8 +19,6 @@
     "@nuxtjs/tailwindcss": "^6.11.4",
     "@twilio/voice-sdk": "^2.11.2",
     "@vueuse/core": "^10.11.1",
-    "ag-grid-community": "^32.3.4",
-    "ag-grid-vue3": "^32.3.4",
     "class-variance-authority": "^0.7.0",
     "clsx": "^2.1.0",
     "gridstack": "^12.4.1",

frontend/pages/[objectName]/[[recordId]]/[[view]].vue

@@ -4,12 +4,9 @@ import { useRoute, useRouter } from 'vue-router'
 import { useApi } from '@/composables/useApi'
 import { useFields, useViewState } from '@/composables/useFieldViews'
 import { usePageLayouts } from '@/composables/usePageLayouts'
-import { useSavedViews } from '@/composables/useSavedViews'
-import type { SavedView } from '@/composables/useSavedViews'
 import ListView from '@/components/views/ListView.vue'
 import DetailView from '@/components/views/DetailViewEnhanced.vue'
 import EditView from '@/components/views/EditViewEnhanced.vue'
-import SavedViewPanel from '@/components/SavedViewPanel.vue'
 import {
   Dialog,
   DialogContent,
@@ -18,23 +15,12 @@ import {
   DialogHeader,
   DialogTitle,
 } from '@/components/ui/dialog'
-import { Button } from '@/components/ui/button'
-import { Input } from '@/components/ui/input'
-import { Label } from '@/components/ui/label'
 
 const route = useRoute()
 const router = useRouter()
 const { api } = useApi()
 const { buildListViewConfig, buildDetailViewConfig, buildEditViewConfig } = useFields()
 const { getDefaultPageLayout } = usePageLayouts()
-const {
-  savedViews,
-  fetchSavedViews,
-  createSavedView,
-  updateSavedView,
-  deleteSavedView,
-  suggestViewName,
-} = useSavedViews()
 
 // Use breadcrumbs composable
 const { setBreadcrumbs } = useBreadcrumbs()
@@ -71,7 +57,6 @@ const {
   fetchRecord,
   deleteRecord,
   deleteRecords,
-  updateRecord,
   handleSave,
 } = useViewState(`/runtime/objects/${objectApiName.value}/records`)
 
@@ -180,27 +165,11 @@ const deleteDialogOpen = ref(false)
 const deleteSubmitting = ref(false)
 const pendingDeleteRows = ref<any[]>([])
 const deleteSummary = ref<{ deletedIds: string[]; deniedIds: string[] } | null>(null)
-const normalizeRecordId = (id: any) => String(id)
-
-const draftEdits = ref<Record<string, Record<string, any>>>({})
-const draftOriginals = ref<Record<string, Record<string, any>>>({})
-const cellErrors = ref<Record<string, Record<string, string>>>({})
-const savingDrafts = ref(false)
 
 const isSearchActive = computed(() => searchQuery.value.trim().length > 0)
 const pendingDeleteCount = computed(() => pendingDeleteRows.value.length)
 const deniedDeleteCount = computed(() => deleteSummary.value?.deniedIds.length ?? 0)
 
-// ── Saved views state ──────────────────────────────────────────────────────
-const activeViewId = ref<string | null>(null)
-const currentSearchPlan = ref<{
-  strategy: string; filters: any[]; sort: any; explanation: string
-} | null>(null)
-const viewPanelOpen = ref(false)
-const saveViewDialogOpen = ref(false)
-const saveViewName = ref('')
-const savingView = ref(false)
-
 // Fetch object definition
 const fetchObjectDefinition = async () => {
   try {
@@ -347,19 +316,6 @@ const searchListRecords = async (
     records.value = options?.append ? [...records.value, ...data] : data
     totalCount.value = total
     searchSummary.value = response?.explanation || ''
-
-    // Capture the plan for the "Save view" feature (only when strategy is query)
-    if (response?.strategy === 'query') {
-      currentSearchPlan.value = {
-        strategy: response.strategy,
-        filters: response.filters || [],
-        sort: response.sort || null,
-        explanation: response.explanation || '',
-      }
-    } else {
-      currentSearchPlan.value = null
-    }
-
     return response
   } catch (e: any) {
     error.value = e.message || 'Failed to search records'
@@ -399,266 +355,17 @@ const handleLoadMore = async (page: number, pageSize: number) => {
   await loadListRecords(page, { append: true, pageSize })
 }
 
-const loadAllListRecords = async () => {
-  if (!records.value.length) {
-    await loadListRecords(1)
-  }
-  const resolvedTotal = totalCount.value ?? records.value.length
-  if (resolvedTotal > records.value.length) {
-    await loadListRecords(1, { append: false, pageSize: resolvedTotal })
-  }
-}
-
-const handleViewChange = async (mode: 'list' | 'spreadsheet') => {
-  if (mode === 'spreadsheet' && !isSearchActive.value) {
-    await loadAllListRecords()
-  }
-}
-
 const handleSearch = async (query: string) => {
   const trimmed = query.trim()
   searchQuery.value = trimmed
   if (!trimmed) {
     searchSummary.value = ''
-    currentSearchPlan.value = null
-    activeViewId.value = null
     await initializeListRecords()
     return
   }
   await searchListRecords(1, { append: false, pageSize: listPageSize.value })
 }
 
-const handleCellEdit = async (payload: { row: any; field: any; newValue: any; oldValue: any }) => {
-  if (!payload?.row?.id || payload.newValue === payload.oldValue) return
-  const recordKey = normalizeRecordId(payload.row.id)
-  const fieldName = payload.field.apiName
-  const originalRow = draftOriginals.value[recordKey]
-  const originalValue = originalRow && Object.prototype.hasOwnProperty.call(originalRow, fieldName)
-    ? originalRow[fieldName]
-    : payload.oldValue
-
-  if (Object.is(payload.newValue, originalValue)) {
-    const nextDrafts = { ...draftEdits.value }
-    const nextRowDrafts = { ...(nextDrafts[recordKey] || {}) }
-    delete nextRowDrafts[fieldName]
-    if (Object.keys(nextRowDrafts).length === 0) {
-      delete nextDrafts[recordKey]
-    } else {
-      nextDrafts[recordKey] = nextRowDrafts
-    }
-    draftEdits.value = nextDrafts
-
-    const nextOriginals = { ...draftOriginals.value }
-    const nextRowOriginals = { ...(nextOriginals[recordKey] || {}) }
-    delete nextRowOriginals[fieldName]
-    if (Object.keys(nextRowOriginals).length === 0) {
-      delete nextOriginals[recordKey]
-    } else {
-      nextOriginals[recordKey] = nextRowOriginals
-    }
-    draftOriginals.value = nextOriginals
-  } else {
-    draftEdits.value = {
-      ...draftEdits.value,
-      [recordKey]: {
-        ...(draftEdits.value[recordKey] || {}),
-        [fieldName]: payload.newValue,
-      },
-    }
-    if (!originalRow || !Object.prototype.hasOwnProperty.call(originalRow, fieldName)) {
-      draftOriginals.value = {
-        ...draftOriginals.value,
-        [recordKey]: {
-          ...(draftOriginals.value[recordKey] || {}),
-          [fieldName]: payload.oldValue,
-        },
-      }
-    }
-  }
-
-  if (cellErrors.value[recordKey]?.[fieldName]) {
-    const nextErrors = { ...cellErrors.value }
-    const nextRowErrors = { ...(nextErrors[recordKey] || {}) }
-    delete nextRowErrors[fieldName]
-    if (Object.keys(nextRowErrors).length === 0) {
-      delete nextErrors[recordKey]
-    } else {
-      nextErrors[recordKey] = nextRowErrors
-    }
-    cellErrors.value = nextErrors
-  }
-}
-
-const handleSaveDrafts = async () => {
-  if (Object.keys(draftEdits.value).length === 0) return
-  savingDrafts.value = true
-  const nextErrors: Record<string, Record<string, string>> = {}
-  const nextDrafts = { ...draftEdits.value }
-  const nextOriginals = { ...draftOriginals.value }
-
-  for (const [recordKey, changes] of Object.entries(draftEdits.value)) {
-    const record = records.value.find(item => normalizeRecordId(item.id) === recordKey)
-    if (!record) {
-      delete nextDrafts[recordKey]
-      delete nextOriginals[recordKey]
-      continue
-    }
-    try {
-      await updateRecord(record.id, changes)
-      delete nextDrafts[recordKey]
-      delete nextOriginals[recordKey]
-    } catch (e: any) {
-      const message = e.message || 'Failed to update record'
-      nextErrors[recordKey] = {}
-      for (const fieldName of Object.keys(changes)) {
-        nextErrors[recordKey][fieldName] = message
-      }
-    }
-  }
-
-  draftEdits.value = nextDrafts
-  draftOriginals.value = nextOriginals
-  cellErrors.value = nextErrors
-  savingDrafts.value = false
-  if (Object.keys(nextErrors).length > 0) {
-    error.value = 'Some updates failed. Fix highlighted cells and try again.'
-  }
-}
-
-const handleDiscardDrafts = () => {
-  for (const [recordKey, fields] of Object.entries(draftOriginals.value)) {
-    const record = records.value.find(item => normalizeRecordId(item.id) === recordKey)
-    if (!record) continue
-    for (const [fieldName, originalValue] of Object.entries(fields)) {
-      record[fieldName] = originalValue
-    }
-  }
-  draftEdits.value = {}
-  draftOriginals.value = {}
-  cellErrors.value = {}
-}
-
-// ── Saved view handlers ────────────────────────────────────────────────────
-
-/**
- * Apply a saved view: execute its stored filters directly without re-running AI.
- */
-const handleApplyView = async (view: SavedView) => {
-  activeViewId.value = view.id
-  searchQuery.value = ''
-  searchSummary.value = view.description || ''
-  currentSearchPlan.value = {
-    strategy: view.strategy,
-    filters: view.filters,
-    sort: view.sort,
-    explanation: view.description || '',
-  }
-  searchLoading.value = true
-  try {
-    const response = await api.post(
-      `/runtime/objects/${objectApiName.value}/records/search`,
-      {
-        filters: view.filters,
-        sort: view.sort,
-        page: 1,
-        pageSize: listPageSize.value,
-      },
-    )
-    const data = response?.data ?? []
-    records.value = data
-    totalCount.value = response?.totalCount ?? data.length
-  } catch (e: any) {
-    error.value = e.message || 'Failed to apply saved view'
-  } finally {
-    searchLoading.value = false
-  }
-}
-
-/**
- * Open the "Save view" dialog, pre-filling the name via AI suggestion.
- */
-const handleSaveView = async () => {
-  if (!currentSearchPlan.value) return
-  saveViewName.value = ''
-  saveViewDialogOpen.value = true
-  // Async-suggest a name while dialog is open
-  const objectLabel = objectDefinition.value?.label || objectApiName.value
-  const suggested = await suggestViewName(
-    objectLabel,
-    currentSearchPlan.value.filters,
-    currentSearchPlan.value.explanation,
-  )
-  // Only auto-fill if user hasn't typed anything yet
-  if (!saveViewName.value) {
-    saveViewName.value = suggested
-  }
-}
-
-/**
- * Confirm the save: persist the view and close the dialog.
- */
-const confirmSaveView = async () => {
-  const name = saveViewName.value.trim()
-  if (!name || !currentSearchPlan.value) return
-  savingView.value = true
-  try {
-    await createSavedView({
-      name,
-      objectApiName: objectApiName.value,
-      filters: currentSearchPlan.value.filters,
-      sort: currentSearchPlan.value.sort,
-      description: currentSearchPlan.value.explanation,
-    })
-    saveViewDialogOpen.value = false
-    saveViewName.value = ''
-  } catch (e: any) {
-    error.value = e.message || 'Failed to save view'
-  } finally {
-    savingView.value = false
-  }
-}
-
-const handleOpenViewManager = () => {
-  viewPanelOpen.value = true
-}
-
-const handleUpdateView = async (id: string, payload: any) => {
-  await updateSavedView(id, payload)
-}
-
-const handleDeleteView = async (view: SavedView) => {
-  await deleteSavedView(view.id)
-  if (activeViewId.value === view.id) {
-    activeViewId.value = null
-    currentSearchPlan.value = null
-    await initializeListRecords()
-  }
-}
-
-watch(
-  () => records.value.map(record => normalizeRecordId(record.id)),
-  (ids) => {
-    const idSet = new Set(ids)
-    const nextDrafts: Record<string, Record<string, any>> = {}
-    const nextOriginals: Record<string, Record<string, any>> = {}
-    const nextErrors: Record<string, Record<string, string>> = {}
-
-    for (const [recordKey, fields] of Object.entries(draftEdits.value)) {
-      if (idSet.has(recordKey)) nextDrafts[recordKey] = fields
-    }
-    for (const [recordKey, fields] of Object.entries(draftOriginals.value)) {
-      if (idSet.has(recordKey)) nextOriginals[recordKey] = fields
-    }
-    for (const [recordKey, fields] of Object.entries(cellErrors.value)) {
-      if (idSet.has(recordKey)) nextErrors[recordKey] = fields
-    }
-
-    draftEdits.value = nextDrafts
-    draftOriginals.value = nextOriginals
-    cellErrors.value = nextErrors
-  }
-)
-
 // Watch for route changes
 watch(() => route.params, async (newParams, oldParams) => {
   // Reset current record when navigating to 'new'
@@ -683,8 +390,6 @@ onMounted(async () => {
   
   if (view.value === 'list') {
     await initializeListRecords()
-    // Load saved views for this object
-    fetchSavedViews(objectApiName.value).catch(() => {})
   } else if (recordId.value && recordId.value !== 'new') {
     await fetchRecord(recordId.value)
   }
@@ -733,13 +438,6 @@ onMounted(async () => {
         :total-count="totalCount"
         :search-summary="searchSummary"
         :base-url="`/runtime/objects`"
-        :draft-edits="draftEdits"
-        :cell-errors="cellErrors"
-        :saving-drafts="savingDrafts"
-        :saved-views="savedViews"
-        :active-view-id="activeViewId"
-        :current-search-plan="currentSearchPlan"
-        :saving-view="savingView"
         selectable
         @row-click="handleRowClick"
         @create="handleCreate"
@@ -748,13 +446,6 @@ onMounted(async () => {
         @search="handleSearch"
         @page-change="handlePageChange"
         @load-more="handleLoadMore"
-        @view-change="handleViewChange"
-        @cell-edit="handleCellEdit"
-        @save-drafts="handleSaveDrafts"
-        @discard-drafts="handleDiscardDrafts"
-        @apply-view="handleApplyView"
-        @save-view="handleSaveView"
-        @open-view-manager="handleOpenViewManager"
       />
 
       <!-- Detail View -->
@@ -826,46 +517,6 @@ onMounted(async () => {
         </DialogFooter>
       </DialogContent>
     </Dialog>
-
-    <!-- Save view dialog -->
-    <Dialog v-model:open="saveViewDialogOpen">
-      <DialogContent class="sm:max-w-[420px]">
-        <DialogHeader>
-          <DialogTitle>Save view</DialogTitle>
-          <DialogDescription>
-            Give this search a name so you can reuse it later.
-          </DialogDescription>
-        </DialogHeader>
-        <div class="space-y-2 py-2">
-          <Label for="view-name">View name</Label>
-          <Input
-            id="view-name"
-            v-model="saveViewName"
-            placeholder="e.g. Cocker Spaniels"
-            @keyup.enter="confirmSaveView"
-          />
-        </div>
-        <DialogFooter>
-          <Button variant="outline" @click="saveViewDialogOpen = false" :disabled="savingView">
-            Cancel
-          </Button>
-          <Button @click="confirmSaveView" :disabled="savingView || !saveViewName.trim()">
-            Save
-          </Button>
-        </DialogFooter>
-      </DialogContent>
-    </Dialog>
-
-    <!-- Saved views slide-over panel -->
-    <SavedViewPanel
-      v-model:open="viewPanelOpen"
-      :views="savedViews"
-      :object-label="objectDefinition?.pluralLabel || objectDefinition?.label || objectApiName"
-      :active-view-id="activeViewId"
-      @apply-view="handleApplyView"
-      @update-view="handleUpdateView"
-      @delete-view="handleDeleteView"
-    />
   </NuxtLayout>
 </template>
 

frontend/pages/app/objects/[objectName]/[[recordId]]/[[view]].vue

@@ -42,7 +42,6 @@ const {
   fetchRecord,
   deleteRecord,
   deleteRecords,
-  updateRecord,
   handleSave,
 } = useViewState(`/runtime/objects/${objectApiName.value}/records`)
 
@@ -91,12 +90,6 @@ const editConfig = computed(() => {
 
 const listPageSize = computed(() => listConfig.value?.pageSize ?? 25)
 const maxFrontendRecords = computed(() => listConfig.value?.maxFrontendRecords ?? 500)
-const normalizeRecordId = (id: any) => String(id)
-
-const draftEdits = ref<Record<string, Record<string, any>>>({})
-const draftOriginals = ref<Record<string, Record<string, any>>>({})
-const cellErrors = ref<Record<string, Record<string, string>>>({})
-const savingDrafts = ref(false)
 
 // Fetch object definition
 const fetchObjectDefinition = async () => {
@@ -219,156 +212,6 @@ const handleLoadMore = async (page: number, pageSize: number) => {
   await loadListRecords(page, { append: true, pageSize })
 }
 
-const loadAllListRecords = async () => {
-  if (!records.value.length) {
-    await loadListRecords(1)
-  }
-  const resolvedTotal = totalCount.value ?? records.value.length
-  if (resolvedTotal > records.value.length) {
-    await loadListRecords(1, { append: false, pageSize: resolvedTotal })
-  }
-}
-
-const handleViewChange = async (mode: 'list' | 'spreadsheet') => {
-  if (mode === 'spreadsheet') {
-    await loadAllListRecords()
-  }
-}
-
-const handleCellEdit = async (payload: { row: any; field: any; newValue: any; oldValue: any }) => {
-  if (!payload?.row?.id || payload.newValue === payload.oldValue) return
-  const recordKey = normalizeRecordId(payload.row.id)
-  const fieldName = payload.field.apiName
-  const originalRow = draftOriginals.value[recordKey]
-  const originalValue = originalRow && Object.prototype.hasOwnProperty.call(originalRow, fieldName)
-    ? originalRow[fieldName]
-    : payload.oldValue
-
-  if (Object.is(payload.newValue, originalValue)) {
-    const nextDrafts = { ...draftEdits.value }
-    const nextRowDrafts = { ...(nextDrafts[recordKey] || {}) }
-    delete nextRowDrafts[fieldName]
-    if (Object.keys(nextRowDrafts).length === 0) {
-      delete nextDrafts[recordKey]
-    } else {
-      nextDrafts[recordKey] = nextRowDrafts
-    }
-    draftEdits.value = nextDrafts
-
-    const nextOriginals = { ...draftOriginals.value }
-    const nextRowOriginals = { ...(nextOriginals[recordKey] || {}) }
-    delete nextRowOriginals[fieldName]
-    if (Object.keys(nextRowOriginals).length === 0) {
-      delete nextOriginals[recordKey]
-    } else {
-      nextOriginals[recordKey] = nextRowOriginals
-    }
-    draftOriginals.value = nextOriginals
-  } else {
-    draftEdits.value = {
-      ...draftEdits.value,
-      [recordKey]: {
-        ...(draftEdits.value[recordKey] || {}),
-        [fieldName]: payload.newValue,
-      },
-    }
-    if (!originalRow || !Object.prototype.hasOwnProperty.call(originalRow, fieldName)) {
-      draftOriginals.value = {
-        ...draftOriginals.value,
-        [recordKey]: {
-          ...(draftOriginals.value[recordKey] || {}),
-          [fieldName]: payload.oldValue,
-        },
-      }
-    }
-  }
-
-  if (cellErrors.value[recordKey]?.[fieldName]) {
-    const nextErrors = { ...cellErrors.value }
-    const nextRowErrors = { ...(nextErrors[recordKey] || {}) }
-    delete nextRowErrors[fieldName]
-    if (Object.keys(nextRowErrors).length === 0) {
-      delete nextErrors[recordKey]
-    } else {
-      nextErrors[recordKey] = nextRowErrors
-    }
-    cellErrors.value = nextErrors
-  }
-}
-
-const handleSaveDrafts = async () => {
-  if (Object.keys(draftEdits.value).length === 0) return
-  savingDrafts.value = true
-  const nextErrors: Record<string, Record<string, string>> = {}
-  const nextDrafts = { ...draftEdits.value }
-  const nextOriginals = { ...draftOriginals.value }
-
-  for (const [recordKey, changes] of Object.entries(draftEdits.value)) {
-    const record = records.value.find(item => normalizeRecordId(item.id) === recordKey)
-    if (!record) {
-      delete nextDrafts[recordKey]
-      delete nextOriginals[recordKey]
-      continue
-    }
-    try {
-      await updateRecord(record.id, changes)
-      delete nextDrafts[recordKey]
-      delete nextOriginals[recordKey]
-    } catch (e: any) {
-      const message = e.message || 'Failed to update record'
-      nextErrors[recordKey] = {}
-      for (const fieldName of Object.keys(changes)) {
-        nextErrors[recordKey][fieldName] = message
-      }
-    }
-  }
-
-  draftEdits.value = nextDrafts
-  draftOriginals.value = nextOriginals
-  cellErrors.value = nextErrors
-  savingDrafts.value = false
-  if (Object.keys(nextErrors).length > 0) {
-    error.value = 'Some updates failed. Fix highlighted cells and try again.'
-  }
-}
-
-const handleDiscardDrafts = () => {
-  for (const [recordKey, fields] of Object.entries(draftOriginals.value)) {
-    const record = records.value.find(item => normalizeRecordId(item.id) === recordKey)
-    if (!record) continue
-    for (const [fieldName, originalValue] of Object.entries(fields)) {
-      record[fieldName] = originalValue
-    }
-  }
-  draftEdits.value = {}
-  draftOriginals.value = {}
-  cellErrors.value = {}
-}
-
-watch(
-  () => records.value.map(record => normalizeRecordId(record.id)),
-  (ids) => {
-    const idSet = new Set(ids)
-    const nextDrafts: Record<string, Record<string, any>> = {}
-    const nextOriginals: Record<string, Record<string, any>> = {}
-    const nextErrors: Record<string, Record<string, string>> = {}
-
-    for (const [recordKey, fields] of Object.entries(draftEdits.value)) {
-      if (idSet.has(recordKey)) nextDrafts[recordKey] = fields
-    }
-    for (const [recordKey, fields] of Object.entries(draftOriginals.value)) {
-      if (idSet.has(recordKey)) nextOriginals[recordKey] = fields
-    }
-    for (const [recordKey, fields] of Object.entries(cellErrors.value)) {
-      if (idSet.has(recordKey)) nextErrors[recordKey] = fields
-    }
-
-    draftEdits.value = nextDrafts
-    draftOriginals.value = nextOriginals
-    cellErrors.value = nextErrors
-  }
-)
-
 // Watch for route changes
 watch(() => route.params, async (newParams, oldParams) => {
   // Reset current record when navigating to 'new'
@@ -435,9 +278,6 @@ onMounted(async () => {
         :data="records"
         :loading="dataLoading"
         :total-count="totalCount"
-        :draft-edits="draftEdits"
-        :cell-errors="cellErrors"
-        :saving-drafts="savingDrafts"
         selectable
         @row-click="handleRowClick"
         @create="handleCreate"
@@ -445,10 +285,6 @@ onMounted(async () => {
         @delete="handleDelete"
         @page-change="handlePageChange"
         @load-more="handleLoadMore"
-        @view-change="handleViewChange"
-        @cell-edit="handleCellEdit"
-        @save-drafts="handleSaveDrafts"
-        @discard-drafts="handleDiscardDrafts"
       />
 
       <!-- Detail View -->

frontend/pages/register.vue

@@ -74,8 +74,24 @@ definePageMeta({
   auth: false
 })
 
+const config = useRuntimeConfig()
 const router = useRouter()
 
+// Extract subdomain from hostname
+const getSubdomain = () => {
+  if (!import.meta.client) return null
+  const hostname = window.location.hostname
+  const parts = hostname.split('.')
+  if (hostname === 'localhost' || hostname === '127.0.0.1') {
+    return null
+  }
+  if (parts.length > 1 && parts[0] !== 'www') {
+    return parts[0]
+  }
+  return null
+}
+
+const subdomain = ref(getSubdomain())
 const email = ref('')
 const password = ref('')
 const firstName = ref('')
@@ -90,17 +106,30 @@ const handleRegister = async () => {
     error.value = ''
     success.value = false
 
-    // Use BFF proxy - subdomain/tenant is handled automatically by Nitro
-    await $fetch('/api/auth/register', {
+    const headers: Record<string, string> = {
+      'Content-Type': 'application/json',
+    }
+
+    if (subdomain.value) {
+      headers['x-tenant-id'] = subdomain.value
+    }
+
+    const response = await fetch(`${config.public.apiBaseUrl}/api/auth/register`, {
       method: 'POST',
-      body: {
+      headers,
+      body: JSON.stringify({
         email: email.value,
         password: password.value,
         firstName: firstName.value || undefined,
         lastName: lastName.value || undefined,
-      },
+      }),
     })
 
+    if (!response.ok) {
+      const data = await response.json()
+      throw new Error(data.message || 'Registration failed')
+    }
+
     success.value = true
 
     // Redirect to login after 2 seconds
@@ -108,10 +137,9 @@ const handleRegister = async () => {
       router.push('/login')
     }, 2000)
   } catch (e: any) {
-    error.value = e.data?.message || e.message || 'Registration failed'
+    error.value = e.message || 'Registration failed'
   } finally {
     loading.value = false
   }
 }
 </script>
-

frontend/pages/setup/users/[id].vue

@@ -33,10 +33,6 @@
                 <Label class="text-muted-foreground">Email</Label>
                 <p class="font-medium">{{ user?.email }}</p>
               </div>
-              <div>
-                <Label class="text-muted-foreground">Alias</Label>
-                <p class="font-medium">{{ user?.alias || 'N/A' }}</p>
-              </div>
               <div>
                 <Label class="text-muted-foreground">First Name</Label>
                 <p class="font-medium">{{ user?.firstName || 'N/A' }}</p>
@@ -214,9 +210,6 @@ const removeRole = async (roleId: string) => {
 
 const getUserName = (user: any) => {
   if (!user) return 'User';
-  if (user.alias) {
-    return user.alias;
-  }
   if (user.firstName || user.lastName) {
     return [user.firstName, user.lastName].filter(Boolean).join(' ');
   }

frontend/pages/setup/users/index.vue

@@ -95,10 +95,6 @@
                     <Label for="lastName">Last Name (Optional)</Label>
                     <Input id="lastName" v-model="newUser.lastName" placeholder="Doe" />
                 </div>
-                <div class="space-y-2">
-                    <Label for="alias">Alias (Optional)</Label>
-                    <Input id="alias" v-model="newUser.alias" placeholder="Display name" />
-                </div>
                 </div>
                 <DialogFooter>
                 <Button variant="outline" @click="showCreateDialog = false">Cancel</Button>
@@ -135,10 +131,6 @@
                     <Label for="edit-lastName">Last Name</Label>
                     <Input id="edit-lastName" v-model="editUser.lastName" placeholder="Doe" />
                 </div>
-                <div class="space-y-2">
-                    <Label for="edit-alias">Alias</Label>
-                    <Input id="edit-alias" v-model="editUser.alias" placeholder="Display name" />
-                </div>
                 </div>
                 <DialogFooter>
                 <Button variant="outline" @click="showEditDialog = false">Cancel</Button>
@@ -195,7 +187,6 @@ const newUser = ref({
   password: '',
   firstName: '',
   lastName: '',
-  alias: '',
 });
 const editUser = ref({
   id: '',
@@ -203,7 +194,6 @@ const editUser = ref({
   password: '',
   firstName: '',
   lastName: '',
-  alias: '',
 });
 const userToDelete = ref<any>(null);
 
@@ -225,7 +215,7 @@ const createUser = async () => {
     await api.post('/setup/users', newUser.value);
     toast.success('User created successfully');
     showCreateDialog.value = false;
-    newUser.value = { email: '', password: '', firstName: '', lastName: '', alias: '' };
+    newUser.value = { email: '', password: '', firstName: '', lastName: '' };
     await loadUsers();
   } catch (error: any) {
     console.error('Failed to create user:', error);
@@ -240,7 +230,6 @@ const openEditDialog = (user: any) => {
     password: '',
     firstName: user.firstName || '',
     lastName: user.lastName || '',
-    alias: user.alias || '',
   };
   showEditDialog.value = true;
 };
@@ -251,7 +240,6 @@ const updateUser = async () => {
       email: editUser.value.email,
       firstName: editUser.value.firstName,
       lastName: editUser.value.lastName,
-      alias: editUser.value.alias,
     };
     if (editUser.value.password) {
       payload.password = editUser.value.password;
@@ -285,9 +273,6 @@ const deleteUser = async () => {
 };
 
 const getUserName = (user: any) => {
-  if (user.alias) {
-    return user.alias;
-  }
   if (user.firstName || user.lastName) {
     return [user.firstName, user.lastName].filter(Boolean).join(' ');
   }

frontend/server/api/[...path].ts

@@ -1,119 +0,0 @@
-import { defineEventHandler, getMethod, readBody, getQuery, createError, getHeader } from 'h3'
-import { getSubdomainFromRequest } from '~/server/utils/tenant'
-import { getSessionToken } from '~/server/utils/session'
-
-/**
- * Catch-all API proxy that forwards requests to the NestJS backend
- * Injects x-tenant-subdomain header and Authorization from HTTP-only cookie
- */
-export default defineEventHandler(async (event) => {
-  const config = useRuntimeConfig()
-  const method = getMethod(event)
-  const path = event.context.params?.path || ''
-  
-  // Get subdomain and session token
-  const subdomain = getSubdomainFromRequest(event)
-  const token = getSessionToken(event)
-  
-  const backendUrl = config.backendUrl || 'http://localhost:3000'
-  
-  // Build the full URL with query parameters
-  const query = getQuery(event)
-  const queryString = new URLSearchParams(query as Record<string, string>).toString()
-  const fullUrl = `${backendUrl}/api/${path}${queryString ? `?${queryString}` : ''}`
-  
-  console.log(`[BFF Proxy] ${method} ${fullUrl} (subdomain: ${subdomain}, hasToken: ${!!token})`)
-  
-  // Build headers to forward
-  const headers: Record<string, string> = {
-    'Content-Type': getHeader(event, 'content-type') || 'application/json',
-  }
-  
-  // Add subdomain header for backend tenant resolution
-  if (subdomain) {
-    headers['x-tenant-subdomain'] = subdomain
-  }
-  
-  // Add auth token from HTTP-only cookie
-  if (token) {
-    headers['Authorization'] = `Bearer ${token}`
-  }
-  
-  // Forward additional headers that might be needed
-  const acceptHeader = getHeader(event, 'accept')
-  if (acceptHeader) {
-    headers['Accept'] = acceptHeader
-  }
-
-  try {
-    // Prepare fetch options
-    const fetchOptions: RequestInit = {
-      method,
-      headers,
-    }
-    
-    // Add body for methods that support it
-    if (['POST', 'PUT', 'PATCH'].includes(method)) {
-      const body = await readBody(event)
-      if (body) {
-        fetchOptions.body = JSON.stringify(body)
-      }
-    }
-    
-    // Make request to backend
-    const response = await fetch(fullUrl, fetchOptions)
-    
-    // Handle non-JSON responses (like file downloads)
-    const contentType = response.headers.get('content-type')
-    
-    if (!response.ok) {
-      // Try to get error details
-      let errorMessage = `Backend error: ${response.status}`
-      let errorData = null
-      
-      try {
-        errorData = await response.json()
-        errorMessage = errorData.message || errorMessage
-      } catch {
-        // Response wasn't JSON
-        try {
-          const text = await response.text()
-          console.error(`[BFF Proxy] Backend error (non-JSON): ${text}`)
-        } catch {}
-      }
-      
-      console.error(`[BFF Proxy] Backend returned ${response.status}: ${errorMessage}`, errorData)
-      
-      throw createError({
-        statusCode: response.status,
-        statusMessage: errorMessage,
-        data: errorData,
-      })
-    }
-    
-    // Return empty response for 204 No Content
-    if (response.status === 204) {
-      return null
-    }
-    
-    // Handle JSON responses
-    if (contentType?.includes('application/json')) {
-      return await response.json()
-    }
-    
-    // Handle other content types (text, etc.)
-    return await response.text()
-    
-  } catch (error: any) {
-    // Re-throw H3 errors
-    if (error.statusCode) {
-      throw error
-    }
-    
-    console.error(`Proxy error for ${method} /api/${path}:`, error)
-    throw createError({
-      statusCode: 502,
-      statusMessage: 'Failed to connect to backend service',
-    })
-  }
-})

frontend/server/api/auth/login.post.ts

@@ -1,81 +0,0 @@
-import { defineEventHandler, readBody, createError } from 'h3'
-import { getSubdomainFromRequest, isCentralSubdomain } from '~/server/utils/tenant'
-import { setSessionCookie, setTenantIdCookie } from '~/server/utils/session'
-
-export default defineEventHandler(async (event) => {
-  const config = useRuntimeConfig()
-  const body = await readBody(event)
-  
-  // Extract subdomain from the request
-  const subdomain = getSubdomainFromRequest(event)
-  
-  if (!subdomain) {
-    throw createError({
-      statusCode: 400,
-      statusMessage: 'Unable to determine tenant from subdomain',
-    })
-  }
-
-  // Determine the backend URL based on whether this is central admin or tenant
-  const isCentral = isCentralSubdomain(subdomain)
-  const backendUrl = config.backendUrl || 'http://localhost:3000'
-  const loginEndpoint = isCentral ? '/api/auth/central/login' : '/api/auth/login'
-
-  try {
-    // Forward login request to NestJS backend with subdomain header
-    const response = await fetch(`${backendUrl}${loginEndpoint}`, {
-      method: 'POST',
-      headers: {
-        'Content-Type': 'application/json',
-        'x-tenant-subdomain': subdomain,
-      },
-      body: JSON.stringify(body),
-    })
-
-    const data = await response.json()
-
-    if (!response.ok) {
-      throw createError({
-        statusCode: response.status,
-        statusMessage: data.message || 'Login failed',
-        data: data,
-      })
-    }
-
-    // Extract token and tenant info from response
-    const { access_token, user, tenantId } = data
-
-    if (!access_token) {
-      throw createError({
-        statusCode: 500,
-        statusMessage: 'No access token received from backend',
-      })
-    }
-
-    // Set HTTP-only cookie with the JWT token
-    setSessionCookie(event, access_token)
-    
-    // Set tenant ID cookie (readable by client for context)
-    // Use tenantId from response, or fall back to subdomain
-    const tenantToStore = tenantId || subdomain
-    setTenantIdCookie(event, tenantToStore)
-
-    // Return user info (but NOT the token - it's in HTTP-only cookie)
-    return {
-      success: true,
-      user,
-      tenantId: tenantToStore,
-    }
-  } catch (error: any) {
-    // Re-throw H3 errors
-    if (error.statusCode) {
-      throw error
-    }
-    
-    console.error('Login proxy error:', error)
-    throw createError({
-      statusCode: 500,
-      statusMessage: 'Failed to connect to authentication service',
-    })
-  }
-})

frontend/server/api/auth/logout.post.ts

@@ -1,37 +0,0 @@
-import { defineEventHandler, createError } from 'h3'
-import { getSubdomainFromRequest } from '~/server/utils/tenant'
-import { getSessionToken, clearSessionCookie, clearTenantIdCookie } from '~/server/utils/session'
-
-export default defineEventHandler(async (event) => {
-  const config = useRuntimeConfig()
-  const subdomain = getSubdomainFromRequest(event)
-  const token = getSessionToken(event)
-
-  const backendUrl = config.backendUrl || 'http://localhost:3000'
-
-  try {
-    // Call backend logout endpoint if we have a token
-    if (token) {
-      await fetch(`${backendUrl}/api/auth/logout`, {
-        method: 'POST',
-        headers: {
-          'Content-Type': 'application/json',
-          'Authorization': `Bearer ${token}`,
-          ...(subdomain && { 'x-tenant-subdomain': subdomain }),
-        },
-      })
-    }
-  } catch (error) {
-    // Log but don't fail - we still want to clear cookies
-    console.error('Backend logout error:', error)
-  }
-
-  // Always clear cookies regardless of backend response
-  clearSessionCookie(event)
-  clearTenantIdCookie(event)
-
-  return {
-    success: true,
-    message: 'Logged out successfully',
-  }
-})

frontend/server/api/auth/me.get.ts

@@ -1,60 +0,0 @@
-import { defineEventHandler, createError } from 'h3'
-import { getSubdomainFromRequest } from '~/server/utils/tenant'
-import { getSessionToken } from '~/server/utils/session'
-
-export default defineEventHandler(async (event) => {
-  const config = useRuntimeConfig()
-  const subdomain = getSubdomainFromRequest(event)
-  const token = getSessionToken(event)
-
-  if (!token) {
-    throw createError({
-      statusCode: 401,
-      statusMessage: 'Not authenticated',
-    })
-  }
-
-  const backendUrl = config.backendUrl || 'http://localhost:3000'
-
-  try {
-    // Fetch current user from backend
-    const response = await fetch(`${backendUrl}/api/auth/me`, {
-      method: 'GET',
-      headers: {
-        'Content-Type': 'application/json',
-        'Authorization': `Bearer ${token}`,
-        ...(subdomain && { 'x-tenant-subdomain': subdomain }),
-      },
-    })
-
-    if (!response.ok) {
-      if (response.status === 401) {
-        throw createError({
-          statusCode: 401,
-          statusMessage: 'Session expired',
-        })
-      }
-      throw createError({
-        statusCode: response.status,
-        statusMessage: 'Failed to fetch user',
-      })
-    }
-
-    const user = await response.json()
-
-    return {
-      authenticated: true,
-      user,
-    }
-  } catch (error: any) {
-    if (error.statusCode) {
-      throw error
-    }
-    
-    console.error('Auth check error:', error)
-    throw createError({
-      statusCode: 500,
-      statusMessage: 'Failed to verify authentication',
-    })
-  }
-})

frontend/server/api/auth/ws-token.get.ts

@@ -1,26 +0,0 @@
-import { defineEventHandler, createError } from 'h3'
-import { getSubdomainFromRequest } from '~/server/utils/tenant'
-import { getSessionToken } from '~/server/utils/session'
-
-/**
- * Get a short-lived token for WebSocket authentication
- * This is needed because socket.io cannot use HTTP-only cookies directly
- */
-export default defineEventHandler(async (event) => {
-  const subdomain = getSubdomainFromRequest(event)
-  const token = getSessionToken(event)
-
-  if (!token) {
-    throw createError({
-      statusCode: 401,
-      statusMessage: 'Not authenticated',
-    })
-  }
-
-  // Return the token for WebSocket use
-  // The token is already validated by being in the HTTP-only cookie
-  return {
-    token,
-    subdomain,
-  }
-})

frontend/server/utils/session.ts

@@ -1,94 +0,0 @@
-import type { H3Event } from 'h3'
-import { getCookie, setCookie, deleteCookie, getHeader } from 'h3'
-
-const SESSION_COOKIE_NAME = 'routebox_session'
-const SESSION_MAX_AGE = 60 * 60 * 24 * 7 // 7 days
-
-export interface SessionData {
-  token: string
-  tenantId: string
-  userId: string
-  email: string
-}
-
-/**
- * Determine if the request is over a secure connection
- * Checks both direct HTTPS and proxy headers
- */
-function isSecureRequest(event: H3Event): boolean {
-  // Check x-forwarded-proto header (set by reverse proxies)
-  const forwardedProto = getHeader(event, 'x-forwarded-proto')
-  if (forwardedProto === 'https') {
-    return true
-  }
-  
-  // Check if NODE_ENV is production (assume HTTPS in production)
-  if (process.env.NODE_ENV === 'production') {
-    return true
-  }
-  
-  return false
-}
-
-/**
- * Get the session token from HTTP-only cookie
- */
-export function getSessionToken(event: H3Event): string | null {
-  return getCookie(event, SESSION_COOKIE_NAME) || null
-}
-
-/**
- * Set the session token in an HTTP-only cookie
- */
-export function setSessionCookie(event: H3Event, token: string): void {
-  const secure = isSecureRequest(event)
-  
-  setCookie(event, SESSION_COOKIE_NAME, token, {
-    httpOnly: true,
-    secure,
-    sameSite: 'lax',
-    maxAge: SESSION_MAX_AGE,
-    path: '/',
-  })
-}
-
-/**
- * Clear the session cookie
- */
-export function clearSessionCookie(event: H3Event): void {
-  deleteCookie(event, SESSION_COOKIE_NAME, {
-    path: '/',
-  })
-}
-
-/**
- * Get tenant ID from a separate cookie (for SSR access)
- * This is NOT the auth token - just tenant context
- */
-export function getTenantIdFromCookie(event: H3Event): string | null {
-  return getCookie(event, 'routebox_tenant') || null
-}
-
-/**
- * Set tenant ID cookie (readable by client for context)
- */
-export function setTenantIdCookie(event: H3Event, tenantId: string): void {
-  const secure = isSecureRequest(event)
-  
-  setCookie(event, 'routebox_tenant', tenantId, {
-    httpOnly: false, // Allow client to read tenant context
-    secure,
-    sameSite: 'lax',
-    maxAge: SESSION_MAX_AGE,
-    path: '/',
-  })
-}
-
-/**
- * Clear tenant ID cookie
- */
-export function clearTenantIdCookie(event: H3Event): void {
-  deleteCookie(event, 'routebox_tenant', {
-    path: '/',
-  })
-}

frontend/server/utils/tenant.ts

@@ -1,39 +0,0 @@
-import type { H3Event } from 'h3'
-import { getHeader } from 'h3'
-
-/**
- * Extract subdomain from the request Host header
- * Handles production domains (tenant1.routebox.co) and development (tenant1.localhost)
- */
-export function getSubdomainFromRequest(event: H3Event): string | null {
-  const host = getHeader(event, 'host') || ''
-  const hostname = host.split(':')[0] // Remove port if present
-
-  const parts = hostname.split('.')
-
-  // For production domains with 3+ parts (e.g., tenant1.routebox.co)
-  if (parts.length >= 3) {
-    const subdomain = parts[0]
-    // Ignore www subdomain
-    if (subdomain === 'www') {
-      return null
-    }
-    return subdomain
-  }
-
-  // For development (e.g., tenant1.localhost)
-  if (parts.length === 2 && parts[1] === 'localhost') {
-    return parts[0]
-  }
-
-  return null
-}
-
-/**
- * Check if the subdomain is a central/admin subdomain
- */
-export function isCentralSubdomain(subdomain: string | null): boolean {
-  if (!subdomain) return false
-  const centralSubdomains = (process.env.CENTRAL_SUBDOMAINS || 'central,admin').split(',')
-  return centralSubdomains.includes(subdomain)
-}