feat: transaction categorization UX improvements and description matching

Add journal entry preview, human-readable account names, auto-apply VAT,
fallback template suggestions, example prompts, invoice match comparison,
and batch result feedback. Also includes user-description-match extension,
describe/batch-describe API routes, improved AI categorization with multi-
suggestion support, and template embedding search.

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

app/(dashboard)/transactions/page.tsx

@@ -19,11 +19,12 @@ import InboxZeroState from '@/components/transactions/InboxZeroState'
 import InvoiceMatchDialog from '@/components/transactions/InvoiceMatchDialog'
 import TransactionBookingDialog from '@/components/transactions/TransactionBookingDialog'
 import QuickReviewDialog from '@/components/transactions/QuickReviewDialog'
+import DescribeTransactionDialog from '@/components/transactions/DescribeTransactionDialog'
 import { EXPENSE_CATEGORIES, INCOME_CATEGORIES } from '@/components/transactions/transaction-types'
 import { getDefaultAccountForCategory, getDefaultVatTreatmentForCategory } from '@/lib/bookkeeping/category-mapping'
 import type { TransactionWithInvoice, ViewMode, CategorizeHandler } from '@/components/transactions/transaction-types'
 import type { TransactionCategory, CreateTransactionInput, Invoice, Customer, VatTreatment } from '@/types'
-import type { SuggestedCategory } from '@/lib/transactions/category-suggestions'
+import type { SuggestedCategory, SuggestedTemplate } from '@/lib/transactions/category-suggestions'
 
 export default function TransactionsPage() {
   const [transactions, setTransactions] = useState<TransactionWithInvoice[]>([])
@@ -33,6 +34,7 @@ export default function TransactionsPage() {
   const [isCreating, setIsCreating] = useState(false)
   const [showSwipeView, setShowSwipeView] = useState(false)
   const [categorySuggestions, setCategorySuggestions] = useState<Record<string, SuggestedCategory[]>>({})
+  const [templateSuggestions, setTemplateSuggestions] = useState<Record<string, SuggestedTemplate[]>>({})
   const [isLoadingSuggestions, setIsLoadingSuggestions] = useState(false)
   const [processingId, setProcessingId] = useState<string | null>(null)
 
@@ -57,6 +59,10 @@ export default function TransactionsPage() {
   const [quickReviewCategory, setQuickReviewCategory] = useState<TransactionCategory | null>(null)
   const [quickReviewLabel, setQuickReviewLabel] = useState('')
 
+  // Describe dialog
+  const [describeDialogOpen, setDescribeDialogOpen] = useState(false)
+  const [describeDialogTransaction, setDescribeDialogTransaction] = useState<TransactionWithInvoice | null>(null)
+
   // Entity type for tooltip context
   const [entityType, setEntityType] = useState<string>('enskild_firma')
 
@@ -130,6 +136,9 @@ export default function TransactionsPage() {
       if (data.suggestions) {
         setCategorySuggestions(data.suggestions)
       }
+      if (data.template_suggestions) {
+        setTemplateSuggestions(data.template_suggestions)
+      }
     } catch {
       // Non-critical
     }
@@ -409,13 +418,29 @@ export default function TransactionsPage() {
   async function handleBatchCategorize(category: TransactionCategory, vatTreatment?: VatTreatment) {
     const ids = Array.from(selectedIds)
     setBatchProgress({ done: 0, total: ids.length })
+    let successes = 0
+    const failures: string[] = []
     for (let i = 0; i < ids.length; i++) {
-      await handleCategorize(ids[i], true, category, vatTreatment)
+      const result = await handleCategorize(ids[i], true, category, vatTreatment)
+      if (result) {
+        successes++
+      } else {
+        const tx = transactions.find((t) => t.id === ids[i])
+        failures.push(tx?.description || ids[i])
+      }
       setBatchProgress({ done: i + 1, total: ids.length })
     }
     setBatchProgress(null)
     setShowBatchSelector(false)
-    toast({ title: 'Klart', description: `${ids.length} transaktioner bokförda` })
+    if (failures.length === 0) {
+      toast({ title: 'Klart', description: `${successes} transaktioner bokförda` })
+    } else {
+      toast({
+        title: 'Delvis klart',
+        description: `${successes} lyckades, ${failures.length} misslyckades: ${failures.slice(0, 3).join(', ')}${failures.length > 3 ? '...' : ''}`,
+        variant: 'destructive',
+      })
+    }
     exitBatchMode()
   }
 
@@ -468,12 +493,40 @@ export default function TransactionsPage() {
     return journalEntryId
   }
 
+  function openDescribeDialog(transaction: TransactionWithInvoice) {
+    setDescribeDialogTransaction(transaction)
+    setDescribeDialogOpen(true)
+  }
+
+  function handleDescribeCategorized(transactionId: string, journalEntryId: string | null) {
+    setExitingIds((prev) => new Set(prev).add(transactionId))
+    setTimeout(() => {
+      setTransactions((prev) =>
+        prev.map((t) =>
+          t.id === transactionId
+            ? { ...t, is_business: true, journal_entry_id: journalEntryId }
+            : t
+        )
+      )
+      setExitingIds((prev) => {
+        const next = new Set(prev)
+        next.delete(transactionId)
+        return next
+      })
+    }, 350)
+  }
+
+  function handleBatchApplied() {
+    fetchTransactions()
+  }
+
   // Swipe view
   if (showSwipeView && uncategorizedTransactions.length > 0) {
     return (
       <SwipeCategorizationView
         transactions={uncategorizedTransactions}
         suggestions={categorySuggestions}
+        templateSuggestions={templateSuggestions}
         onCategorize={handleCategorize}
         onMatchInvoice={handleMatchInvoice}
         onClose={() => setShowSwipeView(false)}
@@ -527,6 +580,7 @@ export default function TransactionsPage() {
                   key={transaction.id}
                   transaction={transaction}
                   suggestions={categorySuggestions[transaction.id]}
+                  templateSuggestions={templateSuggestions[transaction.id]}
                   processingId={processingId}
                   isBatchMode={isBatchMode}
                   isSelected={selectedIds.has(transaction.id)}
@@ -535,6 +589,7 @@ export default function TransactionsPage() {
                   onMarkPrivate={handleMarkPrivate}
                   onOpenMatchDialog={openMatchDialog}
                   onOpenCategoryDialog={openCategoryDialog}
+                  onOpenDescribe={openDescribeDialog}
                   onOpenQuickReview={handleOpenQuickReview}
                   onToggleSelect={toggleBatchSelect}
                 />
@@ -603,6 +658,14 @@ export default function TransactionsPage() {
         onConfirm={handleQuickReviewConfirm}
       />
 
+      <DescribeTransactionDialog
+        open={describeDialogOpen}
+        onOpenChange={setDescribeDialogOpen}
+        transaction={describeDialogTransaction}
+        onCategorized={handleDescribeCategorized}
+        onBatchApplied={handleBatchApplied}
+      />
+
       <Dialog open={isDialogOpen} onOpenChange={setIsDialogOpen}>
         <DialogContent>
           <DialogHeader>

app/api/invoices/[id]/send/__tests__/route.test.ts

@@ -72,6 +72,8 @@ describe('POST /api/invoices/[id]/send', () => {
         unit: 'tim',
         unit_price: 1000,
         line_total: 10000,
+        vat_rate: 25,
+        vat_amount: 2500,
         created_at: '2024-06-15T14:30:00Z',
       },
     ],

app/api/invoices/__tests__/route.test.ts

@@ -318,6 +318,8 @@ describe('POST /api/invoices (create credit note)', () => {
         unit: 'tim',
         unit_price: 1000,
         line_total: 10000,
+        vat_rate: 25,
+        vat_amount: 2500,
         created_at: '2024-06-15T14:30:00Z',
       },
     ]
@@ -385,6 +387,8 @@ describe('POST /api/invoices (create credit note)', () => {
           unit: 'st',
           unit_price: 1000,
           line_total: 1000,
+          vat_rate: 25,
+          vat_amount: 250,
           created_at: '2024-06-15T14:30:00Z',
         },
       ],

app/api/transactions/[id]/categorize/__tests__/route.test.ts

@@ -160,7 +160,9 @@ describe('POST /api/transactions/[id]/categorize', () => {
       'GitHub',
       '6200',
       '1930',
-      false
+      false,
+      undefined,
+      undefined
     )
     expect(emitSpy).toHaveBeenCalledWith(
       expect.objectContaining({ type: 'transaction.categorized' })

app/api/transactions/[id]/categorize/route.ts

@@ -256,7 +256,9 @@ export async function POST(
         transaction.merchant_name,
         mappingResult.debit_account,
         mappingResult.credit_account,
-        !is_business
+        !is_business,
+        body.user_description,
+        body.template_id
       )
     } catch (err) {
       console.error('Failed to save mapping rule:', err)

app/api/transactions/[id]/describe/__tests__/route.test.ts

@@ -0,0 +1,200 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest'
+import {
+  createMockRequest,
+  createMockRouteParams,
+  createQueuedMockSupabase,
+  makeTransaction,
+  parseJsonResponse,
+} from '@/tests/helpers'
+
+// Mock init
+vi.mock('@/lib/init', () => ({ ensureInitialized: vi.fn() }))
+
+// Mock template embeddings
+const mockFindSimilarTemplates = vi.fn().mockResolvedValue([])
+vi.mock('@/lib/bookkeeping/template-embeddings', () => ({
+  findSimilarTemplates: (...args: unknown[]) => mockFindSimilarTemplates(...args),
+}))
+
+// Mock Supabase
+const mockCreateClient = vi.fn()
+vi.mock('@/lib/supabase/server', () => ({
+  createClient: (...args: unknown[]) => mockCreateClient(...args),
+}))
+
+describe('POST /api/transactions/[id]/describe', () => {
+  let POST: typeof import('../route').POST
+
+  beforeEach(async () => {
+    vi.clearAllMocks()
+    const mod = await import('../route')
+    POST = mod.POST
+  })
+
+  it('returns 401 when not authenticated', async () => {
+    const { supabase } = createQueuedMockSupabase()
+    supabase.auth.getUser.mockResolvedValue({
+      data: { user: null },
+      error: { message: 'Not authenticated' },
+    })
+    mockCreateClient.mockResolvedValue(supabase)
+
+    const req = createMockRequest('/api/transactions/test-id/describe', {
+      method: 'POST',
+      body: { description: 'business lunch' },
+    })
+
+    const res = await POST(req, createMockRouteParams({ id: 'test-id' }))
+    const { status, body } = await parseJsonResponse(res)
+
+    expect(status).toBe(401)
+    expect(body).toHaveProperty('error', 'Unauthorized')
+  })
+
+  it('returns 400 for invalid body (description too short)', async () => {
+    const { supabase } = createQueuedMockSupabase()
+    supabase.auth.getUser.mockResolvedValue({
+      data: { user: { id: 'user-1' } },
+      error: null,
+    })
+    mockCreateClient.mockResolvedValue(supabase)
+
+    const req = createMockRequest('/api/transactions/test-id/describe', {
+      method: 'POST',
+      body: { description: 'ab' },
+    })
+
+    const res = await POST(req, createMockRouteParams({ id: 'test-id' }))
+    const { status } = await parseJsonResponse(res)
+
+    expect(status).toBe(400)
+  })
+
+  it('returns 404 when transaction not found', async () => {
+    const { supabase, enqueueMany } = createQueuedMockSupabase()
+    supabase.auth.getUser.mockResolvedValue({
+      data: { user: { id: 'user-1' } },
+      error: null,
+    })
+    enqueueMany([
+      // transaction fetch
+      { data: null, error: { message: 'Not found' } },
+    ])
+    mockCreateClient.mockResolvedValue(supabase)
+
+    const req = createMockRequest('/api/transactions/nonexistent/describe', {
+      method: 'POST',
+      body: { description: 'business lunch' },
+    })
+
+    const res = await POST(req, createMockRouteParams({ id: 'nonexistent' }))
+    const { status, body } = await parseJsonResponse(res)
+
+    expect(status).toBe(404)
+    expect(body).toHaveProperty('error', 'Transaction not found')
+  })
+
+  it('returns template candidates on happy path', async () => {
+    const tx = makeTransaction({
+      id: 'tx-1',
+      merchant_name: 'Restaurant XYZ',
+      amount: -450,
+    })
+
+    mockFindSimilarTemplates.mockResolvedValueOnce([
+      {
+        template: {
+          id: 'restaurant_dining',
+          name_sv: 'Restaurangbesök',
+          name_en: 'Restaurant dining',
+          group: 'representation',
+          debit_account: '6071',
+          credit_account: '1930',
+          description_sv: 'Representation - restaurang',
+        },
+        confidence: 0.82,
+      },
+    ])
+
+    const { supabase, enqueueMany } = createQueuedMockSupabase()
+    supabase.auth.getUser.mockResolvedValue({
+      data: { user: { id: 'user-1' } },
+      error: null,
+    })
+    enqueueMany([
+      // transaction fetch
+      { data: tx, error: null },
+      // company_settings
+      { data: { entity_type: 'enskild_firma' }, error: null },
+      // batch candidate count
+      { data: null, error: null, count: 3 },
+    ])
+    mockCreateClient.mockResolvedValue(supabase)
+
+    const req = createMockRequest('/api/transactions/tx-1/describe', {
+      method: 'POST',
+      body: { description: 'business lunch with client' },
+    })
+
+    const res = await POST(req, createMockRouteParams({ id: 'tx-1' }))
+    const { status, body } = await parseJsonResponse<{ data: Record<string, unknown> }>(res)
+
+    expect(status).toBe(200)
+    expect(body.data.templates).toHaveLength(1)
+    expect(body.data.needs_more_detail).toBe(false)
+    expect(body.data.user_description).toBe('business lunch with client')
+    expect(body.data.batch_candidate_count).toBe(3)
+    expect(body.data.merchant_name).toBe('Restaurant XYZ')
+
+    // Verify findSimilarTemplates was called with the user description
+    expect(mockFindSimilarTemplates).toHaveBeenCalledWith(
+      expect.objectContaining({ id: 'tx-1' }),
+      'enskild_firma',
+      10,
+      'business lunch with client'
+    )
+  })
+
+  it('sets needs_more_detail when confidence is low', async () => {
+    const tx = makeTransaction({ id: 'tx-2', merchant_name: null })
+
+    mockFindSimilarTemplates.mockResolvedValueOnce([
+      {
+        template: {
+          id: 'misc',
+          name_sv: 'Diverse',
+          name_en: 'Miscellaneous',
+          group: 'other',
+          debit_account: '6991',
+          credit_account: '1930',
+          description_sv: 'Okategoriserad utgift',
+        },
+        confidence: 0.4,
+      },
+    ])
+
+    const { supabase, enqueueMany } = createQueuedMockSupabase()
+    supabase.auth.getUser.mockResolvedValue({
+      data: { user: { id: 'user-1' } },
+      error: null,
+    })
+    enqueueMany([
+      // transaction fetch
+      { data: tx, error: null },
+      // company_settings
+      { data: { entity_type: 'enskild_firma' }, error: null },
+    ])
+    mockCreateClient.mockResolvedValue(supabase)
+
+    const req = createMockRequest('/api/transactions/tx-2/describe', {
+      method: 'POST',
+      body: { description: 'some kind of payment' },
+    })
+
+    const res = await POST(req, createMockRouteParams({ id: 'tx-2' }))
+    const { status, body } = await parseJsonResponse<{ data: Record<string, unknown> }>(res)
+
+    expect(status).toBe(200)
+    expect(body.data.needs_more_detail).toBe(true)
+  })
+})

app/api/transactions/[id]/describe/route.ts

@@ -0,0 +1,98 @@
+import { createClient } from '@/lib/supabase/server'
+import { NextResponse } from 'next/server'
+import { ensureInitialized } from '@/lib/init'
+import { validateBody } from '@/lib/api/validate'
+import { DescribeTransactionSchema } from '@/lib/api/schemas'
+import { findSimilarTemplates } from '@/lib/bookkeeping/template-embeddings'
+import type { Transaction, EntityType } from '@/types'
+
+ensureInitialized()
+
+export async function POST(
+  request: Request,
+  { params }: { params: Promise<{ id: string }> }
+) {
+  const supabase = await createClient()
+  const { id } = await params
+
+  const { data: { user } } = await supabase.auth.getUser()
+
+  if (!user) {
+    return NextResponse.json({ error: 'Unauthorized' }, { status: 401 })
+  }
+
+  const validation = await validateBody(request, DescribeTransactionSchema)
+  if (!validation.success) return validation.response
+  const { description } = validation.data
+
+  // Fetch the transaction (validates ownership)
+  const { data: transaction, error: fetchError } = await supabase
+    .from('transactions')
+    .select('*')
+    .eq('id', id)
+    .eq('user_id', user.id)
+    .single()
+
+  if (fetchError || !transaction) {
+    return NextResponse.json({ error: 'Transaction not found' }, { status: 404 })
+  }
+
+  // Fetch entity type
+  const { data: settings } = await supabase
+    .from('company_settings')
+    .select('entity_type')
+    .eq('user_id', user.id)
+    .single()
+
+  const entityType: EntityType = (settings?.entity_type as EntityType) || 'enskild_firma'
+
+  // Run embedding search with user description dominating the query
+  const templates = await findSimilarTemplates(
+    transaction as Transaction,
+    entityType,
+    10,
+    description
+  )
+
+  // Flag if top confidence is too low
+  const needsMoreDetail = templates.length === 0 || templates[0].confidence < 0.55
+
+  // Count uncategorized sibling transactions from same merchant
+  let batchCandidateCount = 0
+  if (transaction.merchant_name) {
+    const { count } = await supabase
+      .from('transactions')
+      .select('id', { count: 'exact', head: true })
+      .eq('user_id', user.id)
+      .eq('merchant_name', transaction.merchant_name)
+      .is('journal_entry_id', null)
+      .neq('id', id)
+
+    batchCandidateCount = count || 0
+  }
+
+  return NextResponse.json({
+    data: {
+      templates: templates.map((m) => ({
+        template_id: m.template.id,
+        name_sv: m.template.name_sv,
+        name_en: m.template.name_en,
+        group: m.template.group,
+        debit_account: m.template.debit_account,
+        credit_account: m.template.credit_account,
+        confidence: m.confidence,
+        description_sv: m.template.description_sv,
+        vat_rate: m.template.vat_rate,
+        vat_treatment: m.template.vat_treatment,
+        deductibility: m.template.deductibility,
+        deductibility_note_sv: m.template.deductibility_note_sv || null,
+        special_rules_sv: m.template.special_rules_sv || null,
+        risk_level: m.template.risk_level,
+      })),
+      needs_more_detail: needsMoreDetail,
+      user_description: description,
+      batch_candidate_count: batchCandidateCount,
+      merchant_name: transaction.merchant_name,
+    },
+  })
+}

app/api/transactions/batch-describe/__tests__/route.test.ts

@@ -0,0 +1,212 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest'
+import {
+  createMockRequest,
+  createQueuedMockSupabase,
+  makeTransaction,
+  parseJsonResponse,
+} from '@/tests/helpers'
+import { eventBus } from '@/lib/events'
+
+// Mock init
+vi.mock('@/lib/init', () => ({ ensureInitialized: vi.fn() }))
+
+// Mock booking templates
+vi.mock('@/lib/bookkeeping/booking-templates', () => ({
+  getTemplateById: vi.fn((id: string) => {
+    if (id === 'office_supplies') {
+      return {
+        id: 'office_supplies',
+        name_sv: 'Kontorsmaterial',
+        name_en: 'Office supplies',
+        group: 'office',
+        debit_account: '6110',
+        credit_account: '1930',
+        fallback_category: 'expense_office',
+        default_private: false,
+        vat_treatment: 'standard_25',
+        vat_rate: 0.25,
+        deductibility: 'full',
+        risk_level: 'LOW',
+        requires_review: false,
+        entity_applicability: 'all',
+        direction: 'expense',
+      }
+    }
+    return null
+  }),
+  buildMappingResultFromTemplate: vi.fn(() => ({
+    rule: null,
+    debit_account: '6110',
+    credit_account: '1930',
+    risk_level: 'LOW',
+    confidence: 1.0,
+    requires_review: false,
+    default_private: false,
+    vat_lines: [],
+    description: 'Kontorsmaterial',
+  })),
+}))
+
+// Mock transaction entries
+const mockCreateTransactionJournalEntry = vi.fn().mockResolvedValue({ id: 'je-1' })
+vi.mock('@/lib/bookkeeping/transaction-entries', () => ({
+  createTransactionJournalEntry: (...args: unknown[]) => mockCreateTransactionJournalEntry(...args),
+}))
+
+// Mock mapping engine
+const mockSaveUserMappingRule = vi.fn().mockResolvedValue(undefined)
+vi.mock('@/lib/bookkeeping/mapping-engine', () => ({
+  saveUserMappingRule: (...args: unknown[]) => mockSaveUserMappingRule(...args),
+}))
+
+// Mock Supabase — set up once, re-configure per test via auth mock + queue
+const mockCreateClient = vi.fn()
+vi.mock('@/lib/supabase/server', () => ({
+  createClient: (...args: unknown[]) => mockCreateClient(...args),
+}))
+
+describe('POST /api/transactions/batch-describe', () => {
+  let POST: typeof import('../route').POST
+
+  beforeEach(async () => {
+    vi.clearAllMocks()
+    eventBus.clear()
+    const mod = await import('../route')
+    POST = mod.POST
+  })
+
+  it('returns 401 when not authenticated', async () => {
+    const { supabase } = createQueuedMockSupabase()
+    supabase.auth.getUser.mockResolvedValue({
+      data: { user: null },
+      error: { message: 'Not authenticated' },
+    })
+    mockCreateClient.mockResolvedValue(supabase)
+
+    const req = createMockRequest('/api/transactions/batch-describe', {
+      method: 'POST',
+      body: {
+        merchant_name: 'Staples',
+        template_id: 'office_supplies',
+        is_business: true,
+      },
+    })
+
+    const res = await POST(req)
+    const { status, body } = await parseJsonResponse(res)
+
+    expect(status).toBe(401)
+    expect(body).toHaveProperty('error', 'Unauthorized')
+  })
+
+  it('returns 400 for invalid template_id', async () => {
+    const { supabase } = createQueuedMockSupabase()
+    supabase.auth.getUser.mockResolvedValue({
+      data: { user: { id: 'user-1' } },
+      error: null,
+    })
+    mockCreateClient.mockResolvedValue(supabase)
+
+    const req = createMockRequest('/api/transactions/batch-describe', {
+      method: 'POST',
+      body: {
+        merchant_name: 'Staples',
+        template_id: 'nonexistent_template',
+        is_business: true,
+      },
+    })
+
+    const res = await POST(req)
+    const { status, body } = await parseJsonResponse(res)
+
+    expect(status).toBe(400)
+    expect(body).toHaveProperty('error', 'Invalid template_id')
+  })
+
+  it('applies template to uncategorized merchant transactions', async () => {
+    const tx1 = makeTransaction({ id: 'tx-1', merchant_name: 'Staples', amount: -299 })
+    const tx2 = makeTransaction({ id: 'tx-2', merchant_name: 'Staples', amount: -150 })
+
+    const { supabase, enqueueMany } = createQueuedMockSupabase()
+    supabase.auth.getUser.mockResolvedValue({
+      data: { user: { id: 'user-1' } },
+      error: null,
+    })
+    enqueueMany([
+      // company_settings
+      { data: { entity_type: 'enskild_firma', fiscal_year_start_month: 1 }, error: null },
+      // fetch uncategorized transactions
+      { data: [tx1, tx2], error: null },
+      // fiscal period upsert for tx1
+      { data: null, error: null },
+      // transaction update for tx1
+      { data: null, error: null },
+      // fiscal period upsert for tx2
+      { data: null, error: null },
+      // transaction update for tx2
+      { data: null, error: null },
+    ])
+    mockCreateClient.mockResolvedValue(supabase)
+
+    const req = createMockRequest('/api/transactions/batch-describe', {
+      method: 'POST',
+      body: {
+        merchant_name: 'Staples',
+        template_id: 'office_supplies',
+        is_business: true,
+        user_description: 'office supplies purchase',
+      },
+    })
+
+    const res = await POST(req)
+    const { status, body } = await parseJsonResponse<{ data: { applied: number; errors: string[] } }>(res)
+
+    expect(status).toBe(200)
+    expect(body.data.applied).toBe(2)
+    expect(body.data.errors).toHaveLength(0)
+
+    // Verify journal entries were created
+    expect(mockCreateTransactionJournalEntry).toHaveBeenCalledTimes(2)
+
+    // Verify mapping rule was saved with user description
+    expect(mockSaveUserMappingRule).toHaveBeenCalledWith(
+      'user-1',
+      'Staples',
+      '6110',
+      '1930',
+      false,
+      'office supplies purchase',
+      'office_supplies'
+    )
+  })
+
+  it('returns 0 applied when no uncategorized transactions exist', async () => {
+    const { supabase, enqueueMany } = createQueuedMockSupabase()
+    supabase.auth.getUser.mockResolvedValue({
+      data: { user: { id: 'user-1' } },
+      error: null,
+    })
+    enqueueMany([
+      // company_settings
+      { data: { entity_type: 'enskild_firma', fiscal_year_start_month: 1 }, error: null },
+      // fetch uncategorized transactions — empty
+      { data: [], error: null },
+    ])
+    mockCreateClient.mockResolvedValue(supabase)
+
+    const req = createMockRequest('/api/transactions/batch-describe', {
+      method: 'POST',
+      body: {
+        merchant_name: 'Unknown Merchant',
+        template_id: 'office_supplies',
+        is_business: true,
+      },
+    })
+
+    const res = await POST(req)
+    const { status, body } = await parseJsonResponse<{ data: { applied: number } }>(res)
+
+    expect(status).toBe(200)
+    expect(body.data.applied).toBe(0)
+  })
+})

app/api/transactions/batch-describe/route.ts

@@ -0,0 +1,171 @@
+import { createClient } from '@/lib/supabase/server'
+import { NextResponse } from 'next/server'
+import { eventBus } from '@/lib/events'
+import { ensureInitialized } from '@/lib/init'
+import { validateBody } from '@/lib/api/validate'
+import { BatchDescribeSchema } from '@/lib/api/schemas'
+import { getTemplateById, buildMappingResultFromTemplate } from '@/lib/bookkeeping/booking-templates'
+import { createTransactionJournalEntry } from '@/lib/bookkeeping/transaction-entries'
+import { saveUserMappingRule } from '@/lib/bookkeeping/mapping-engine'
+import type { Transaction, EntityType, TransactionCategory } from '@/types'
+
+ensureInitialized()
+
+export async function POST(request: Request) {
+  const supabase = await createClient()
+
+  const { data: { user } } = await supabase.auth.getUser()
+
+  if (!user) {
+    return NextResponse.json({ error: 'Unauthorized' }, { status: 401 })
+  }
+
+  const validation = await validateBody(request, BatchDescribeSchema)
+  if (!validation.success) return validation.response
+  const { merchant_name, template_id, is_business, user_description } = validation.data
+
+  // Look up the template
+  const template = getTemplateById(template_id)
+  if (!template) {
+    return NextResponse.json({ error: 'Invalid template_id' }, { status: 400 })
+  }
+
+  // Fetch entity type and fiscal year start
+  const { data: settings } = await supabase
+    .from('company_settings')
+    .select('entity_type, fiscal_year_start_month')
+    .eq('user_id', user.id)
+    .single()
+
+  const entityType: EntityType = (settings?.entity_type as EntityType) || 'enskild_firma'
+  const fiscalYearStartMonth: number = settings?.fiscal_year_start_month ?? 1
+
+  // Fetch all uncategorized transactions from the specified merchant (limit 50)
+  const { data: transactions, error: fetchError } = await supabase
+    .from('transactions')
+    .select('*')
+    .eq('user_id', user.id)
+    .eq('merchant_name', merchant_name)
+    .is('journal_entry_id', null)
+    .order('date', { ascending: true })
+    .limit(50)
+
+  if (fetchError || !transactions || transactions.length === 0) {
+    return NextResponse.json({
+      data: { applied: 0, errors: [] },
+    })
+  }
+
+  const finalCategory: TransactionCategory = is_business
+    ? template.fallback_category
+    : 'private'
+
+  let applied = 0
+  const errors: string[] = []
+
+  for (const tx of transactions) {
+    try {
+      const mappingResult = buildMappingResultFromTemplate(
+        template,
+        tx as Transaction,
+        entityType
+      )
+
+      // Ensure fiscal period exists
+      const txDate = new Date(tx.date)
+      const txMonth = txDate.getMonth() + 1
+      const txYear = txDate.getFullYear()
+
+      let periodStartYear: number
+      if (fiscalYearStartMonth === 1) {
+        periodStartYear = txYear
+      } else if (txMonth >= fiscalYearStartMonth) {
+        periodStartYear = txYear
+      } else {
+        periodStartYear = txYear - 1
+      }
+
+      const startMonth = String(fiscalYearStartMonth).padStart(2, '0')
+      const periodStart = `${periodStartYear}-${startMonth}-01`
+      const endYear = fiscalYearStartMonth === 1 ? periodStartYear : periodStartYear + 1
+      const endMonth = fiscalYearStartMonth === 1 ? 12 : fiscalYearStartMonth - 1
+      const lastDay = new Date(endYear, endMonth, 0).getDate()
+      const periodEnd = `${endYear}-${String(endMonth).padStart(2, '0')}-${String(lastDay).padStart(2, '0')}`
+      const periodName = fiscalYearStartMonth === 1
+        ? `Räkenskapsår ${periodStartYear}`
+        : `Räkenskapsår ${periodStartYear}/${endYear}`
+
+      await supabase
+        .from('fiscal_periods')
+        .upsert({
+          user_id: user.id,
+          name: periodName,
+          period_start: periodStart,
+          period_end: periodEnd,
+        }, { onConflict: 'user_id,period_start,period_end' })
+
+      // Create journal entry
+      let journalEntryId: string | null = null
+      try {
+        const journalEntry = await createTransactionJournalEntry(
+          user.id,
+          tx as Transaction,
+          mappingResult
+        )
+        if (journalEntry) {
+          journalEntryId = journalEntry.id
+        }
+      } catch (err) {
+        console.error(`[batch-describe] Journal entry failed for ${tx.id}:`, err)
+      }
+
+      // Update the transaction
+      await supabase
+        .from('transactions')
+        .update({
+          is_business,
+          category: finalCategory,
+          journal_entry_id: journalEntryId,
+        })
+        .eq('id', tx.id)
+
+      await eventBus.emit({
+        type: 'transaction.categorized',
+        payload: {
+          transaction: tx as Transaction,
+          account: mappingResult.debit_account,
+          taxCode: mappingResult.vat_lines[0]?.account_number || '',
+          userId: user.id,
+        },
+      })
+
+      applied++
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : 'Unknown error'
+      errors.push(`${tx.id}: ${msg}`)
+    }
+  }
+
+  // Save a mapping rule for future auto-categorization
+  if (applied > 0) {
+    try {
+      const sampleTx = transactions[0] as Transaction
+      const sampleResult = buildMappingResultFromTemplate(template, sampleTx, entityType)
+      await saveUserMappingRule(
+        user.id,
+        merchant_name,
+        sampleResult.debit_account,
+        sampleResult.credit_account,
+        !is_business,
+        user_description,
+        template_id
+      )
+    } catch {
+      // Non-critical
+    }
+  }
+
+  return NextResponse.json({
+    data: { applied, errors },
+  })
+}

app/api/transactions/suggest-categories/route.ts

@@ -3,6 +3,24 @@ import { NextResponse } from 'next/server'
 import { getSuggestedCategories, mergeAiSuggestions, getSuggestedTemplates, type SuggestedCategory, type SuggestedTemplate } from '@/lib/transactions/category-suggestions'
 import type { Transaction, TransactionCategory, EntityType } from '@/types'
 
+// Minimum confidence threshold — below this, suggestions are considered weak
+// and we trigger on-demand AI categorization to get better results.
+const WEAK_SUGGESTION_THRESHOLD = 0.55
+
+/**
+ * Check if suggestions are "weak" — only history-based fallbacks
+ * with no strong rule/pattern/AI match.
+ */
+function hasWeakSuggestions(result: SuggestedCategory[]): boolean {
+  if (result.length === 0) return true
+  // Weak if the best suggestion is below threshold
+  const bestConfidence = Math.max(...result.map((s) => s.confidence))
+  if (bestConfidence < WEAK_SUGGESTION_THRESHOLD) return true
+  // Weak if all suggestions are from history only (no rule/pattern/ai match)
+  if (result.every((s) => s.source === 'history')) return true
+  return false
+}
+
 /**
  * POST /api/transactions/suggest-categories
  * Batch endpoint for getting category suggestions for multiple transactions
@@ -70,11 +88,18 @@ export async function POST(request: Request) {
     .eq('extension_id', 'ai-categorization')
     .in('key', aiKeys)
 
-  const aiSuggestionsMap: Record<string, { category: string; basAccount: string; confidence: number; reasoning: string }> = {}
+  type AiSuggestion = { category: string; basAccount: string; confidence: number; reasoning: string }
+  const aiSuggestionsMap: Record<string, AiSuggestion[]> = {}
   if (aiRecords) {
     for (const record of aiRecords) {
       const txId = record.key.replace('suggestion:', '')
-      aiSuggestionsMap[txId] = record.value as { category: string; basAccount: string; confidence: number; reasoning: string }
+      const value = record.value
+      // Handle both single object (old) and array (new) storage formats
+      if (Array.isArray(value)) {
+        aiSuggestionsMap[txId] = value as AiSuggestion[]
+      } else {
+        aiSuggestionsMap[txId] = [value as AiSuggestion]
+      }
     }
   }
 
@@ -86,9 +111,10 @@ export async function POST(request: Request) {
     .single()
   const entityType = (settings?.entity_type as EntityType) || undefined
 
-  // Generate suggestions for each transaction
+  // Generate initial suggestions for each transaction
   const suggestions: Record<string, SuggestedCategory[]> = {}
   const template_suggestions: Record<string, SuggestedTemplate[]> = {}
+  const needsAiIds: string[] = []
 
   for (const tx of transactions) {
     let result = getSuggestedCategories(
@@ -97,15 +123,75 @@ export async function POST(request: Request) {
       categoryHistory
     )
 
-    // Merge AI suggestions if available
-    const aiSuggestion = aiSuggestionsMap[tx.id]
-    if (aiSuggestion) {
-      result = mergeAiSuggestions(result, [aiSuggestion])
+    // Merge pre-computed AI suggestions if available
+    const aiSuggestions = aiSuggestionsMap[tx.id]
+    if (aiSuggestions && aiSuggestions.length > 0) {
+      result = mergeAiSuggestions(result, aiSuggestions, tx.amount)
+    } else if (hasWeakSuggestions(result)) {
+      // No pre-computed AI suggestion AND rule-based suggestions are weak —
+      // mark this transaction for on-demand AI categorization
+      needsAiIds.push(tx.id)
     }
 
     suggestions[tx.id] = result
     template_suggestions[tx.id] = await getSuggestedTemplates(tx as Transaction, entityType)
   }
 
+  // Trigger on-demand AI categorization for transactions with weak suggestions
+  if (needsAiIds.length > 0) {
+    console.log(
+      `[suggest-categories] ${needsAiIds.length} transactions have weak suggestions, triggering on-demand AI:`,
+      needsAiIds.map((id) => {
+        const tx = transactions.find((t) => t.id === id)
+        return tx
+          ? { id, description: tx.description, merchant_name: tx.merchant_name, amount: tx.amount }
+          : { id }
+      })
+    )
+
+    try {
+      const { categorizeTransactions } = await import(
+        '@/extensions/general/ai-categorization'
+      )
+      const aiResults = await categorizeTransactions(user.id, needsAiIds)
+
+      console.log(
+        '[suggest-categories] AI categorization results:',
+        aiResults.map((r) => ({
+          id: r.transactionId,
+          category: r.category,
+          basAccount: r.basAccount,
+          confidence: r.confidence,
+          reasoning: r.reasoning,
+          isPrivate: r.isPrivate,
+          templateId: r.templateId,
+        }))
+      )
+
+      // Group AI results by transactionId (AI now returns 2 per transaction)
+      const groupedAi: Record<string, { category: string; basAccount: string; confidence: number; reasoning: string }[]> = {}
+      for (const aiResult of aiResults) {
+        if (!groupedAi[aiResult.transactionId]) {
+          groupedAi[aiResult.transactionId] = []
+        }
+        groupedAi[aiResult.transactionId].push({
+          category: aiResult.category,
+          basAccount: aiResult.basAccount,
+          confidence: aiResult.confidence,
+          reasoning: aiResult.reasoning,
+        })
+      }
+
+      for (const [txId, aiSuggestions] of Object.entries(groupedAi)) {
+        const existing = suggestions[txId] || []
+        const tx = transactions.find((t) => t.id === txId)
+        suggestions[txId] = mergeAiSuggestions(existing, aiSuggestions, tx?.amount)
+      }
+    } catch (err) {
+      // AI categorization is non-blocking — log and continue with existing suggestions
+      console.error('[suggest-categories] On-demand AI categorization failed:', err)
+    }
+  }
+
   return NextResponse.json({ suggestions, template_suggestions })
 }

components/bookkeeping/JournalEntryList.tsx

@@ -206,8 +206,11 @@ export default function JournalEntryList({ periodId }: Props) {
                 </div>
               </button>
 
-              {isExpanded && lines.length > 0 && (
+              {isExpanded && (
                 <CardContent className="pt-0 pb-4">
+                  {lines.length === 0 ? (
+                    <p className="text-sm text-muted-foreground py-2">Inga kontorader hittades för denna verifikation.</p>
+                  ) : (
                   <table className="w-full text-sm">
                     <thead>
                       <tr className="border-b text-left text-muted-foreground">
@@ -261,6 +264,7 @@ export default function JournalEntryList({ periodId }: Props) {
                       </tr>
                     </tfoot>
                   </table>
+                  )}
 
                   <JournalEntryAttachments
                     journalEntryId={entry.id}

components/extensions/general/UserDescriptionMatchWorkspace.tsx

@@ -0,0 +1,15 @@
+'use client'
+
+import type { WorkspaceComponentProps } from '@/lib/extensions/workspace-registry'
+import EmptyExtensionState from '@/components/extensions/shared/EmptyExtensionState'
+import { TextSearch } from 'lucide-react'
+
+export default function UserDescriptionMatchWorkspace({ userId }: WorkspaceComponentProps) {
+  return (
+    <EmptyExtensionState
+      title="Beskrivningsmatchning"
+      description="Beskriv transaktioner med egna ord vid kategorisering. Systemet lär sig automatiskt och applicerar på framtida transaktioner från samma leverantör."
+      icon={<TextSearch className="h-12 w-12 text-muted-foreground/40 mb-4" />}
+    />
+  )
+}

components/transactions/DescribeTransactionDialog.tsx

@@ -0,0 +1,539 @@
+'use client'
+
+import { useState } from 'react'
+import { Button } from '@/components/ui/button'
+import { Badge } from '@/components/ui/badge'
+import { Card, CardContent } from '@/components/ui/card'
+import { Textarea } from '@/components/ui/textarea'
+import {
+  Dialog,
+  DialogContent,
+  DialogHeader,
+  DialogTitle,
+  DialogDescription,
+} from '@/components/ui/dialog'
+import { useToast } from '@/components/ui/use-toast'
+import { formatCurrency, formatDate } from '@/lib/utils'
+import {
+  ArrowUpRight,
+  ArrowDownRight,
+  Loader2,
+  Search,
+  ArrowLeft,
+  Check,
+  CheckCircle2,
+  AlertTriangle,
+} from 'lucide-react'
+import JournalEntryPreview from './JournalEntryPreview'
+import { formatAccountWithName } from '@/lib/bookkeeping/client-account-names'
+import type { TransactionWithInvoice } from './transaction-types'
+
+interface TemplateMatch {
+  template_id: string
+  name_sv: string
+  name_en: string
+  group: string
+  debit_account: string
+  credit_account: string
+  confidence: number
+  description_sv: string
+  vat_rate: number
+  vat_treatment: string | null
+  deductibility: 'full' | 'non_deductible' | 'conditional'
+  deductibility_note_sv: string | null
+  special_rules_sv: string | null
+  risk_level: string
+}
+
+interface DescribeResult {
+  templates: TemplateMatch[]
+  needs_more_detail: boolean
+  user_description: string
+  batch_candidate_count: number
+  merchant_name: string | null
+}
+
+interface DescribeTransactionDialogProps {
+  open: boolean
+  onOpenChange: (open: boolean) => void
+  transaction: TransactionWithInvoice | null
+  onCategorized: (transactionId: string, journalEntryId: string | null) => void
+  onBatchApplied?: (count: number) => void
+}
+
+type Step = 'describe' | 'pick' | 'batch'
+
+function getExamplePrompts(transaction: TransactionWithInvoice): string[] {
+  const desc = (transaction.description || '').toLowerCase()
+  const isExpense = transaction.amount < 0
+
+  if (!isExpense) {
+    return ['Konsultarvode', 'Forsaljning av varor', 'Aterbetalning']
+  }
+
+  // Contextual suggestions based on description keywords
+  if (desc.includes('restaurang') || desc.includes('lunch') || desc.includes('middag') || desc.includes('mat')) {
+    return ['Lunch med kund', 'Personalmiddag', 'Fika till kontoret']
+  }
+  if (desc.includes('hotel') || desc.includes('hotell') || desc.includes('boende') || desc.includes('resa')) {
+    return ['Tjansteresa', 'Hotell konferens', 'Flygbiljett']
+  }
+  if (desc.includes('uber') || desc.includes('taxi') || desc.includes('bolt') || desc.includes('sj ')) {
+    return ['Taxi till kund', 'Tjansteresa', 'Pendling']
+  }
+  if (desc.includes('google') || desc.includes('meta') || desc.includes('facebook') || desc.includes('linkedin')) {
+    return ['Online-annonsering', 'SaaS-prenumeration', 'Marknadsforingskampanj']
+  }
+  if (desc.includes('amazon') || desc.includes('aws') || desc.includes('azure') || desc.includes('cloud')) {
+    return ['Serverhosting', 'SaaS-prenumeration', 'Kontorsmaterial']
+  }
+
+  // Generic expense suggestions
+  return ['Kontorsmaterial', 'SaaS-prenumeration', 'Konsulttjanst', 'Reklam']
+}
+
+export default function DescribeTransactionDialog({
+  open,
+  onOpenChange,
+  transaction,
+  onCategorized,
+  onBatchApplied,
+}: DescribeTransactionDialogProps) {
+  const { toast } = useToast()
+  const [step, setStep] = useState<Step>('describe')
+  const [description, setDescription] = useState('')
+  const [isSearching, setIsSearching] = useState(false)
+  const [isBooking, setIsBooking] = useState(false)
+  const [isBatchApplying, setIsBatchApplying] = useState(false)
+  const [describeResult, setDescribeResult] = useState<DescribeResult | null>(null)
+  const [selectedTemplateId, setSelectedTemplateId] = useState<string | null>(null)
+
+  function resetState() {
+    setStep('describe')
+    setDescription('')
+    setIsSearching(false)
+    setIsBooking(false)
+    setIsBatchApplying(false)
+    setDescribeResult(null)
+    setSelectedTemplateId(null)
+  }
+
+  function handleOpenChange(isOpen: boolean) {
+    if (!isOpen) {
+      resetState()
+    }
+    onOpenChange(isOpen)
+  }
+
+  async function handleSearch() {
+    if (!transaction || description.trim().length < 3) return
+
+    setIsSearching(true)
+    try {
+      const response = await fetch(`/api/transactions/${transaction.id}/describe`, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({ description: description.trim() }),
+      })
+      const result = await response.json()
+      if (!response.ok) {
+        toast({
+          title: 'Fel',
+          description: result.error || 'Kunde inte soka mallar',
+          variant: 'destructive',
+        })
+        setIsSearching(false)
+        return
+      }
+
+      setDescribeResult(result.data)
+      setSelectedTemplateId(null)
+      setStep('pick')
+    } catch {
+      toast({
+        title: 'Fel',
+        description: 'Nagot gick fel vid sokning',
+        variant: 'destructive',
+      })
+    }
+    setIsSearching(false)
+  }
+
+  async function handleBook() {
+    if (!transaction || !selectedTemplateId || !describeResult) return
+
+    setIsBooking(true)
+    try {
+      const response = await fetch(`/api/transactions/${transaction.id}/categorize`, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({
+          is_business: true,
+          template_id: selectedTemplateId,
+          user_description: describeResult.user_description,
+        }),
+      })
+      const result = await response.json()
+      if (!response.ok) {
+        toast({
+          title: 'Fel',
+          description: result.error || 'Kunde inte bokfora transaktion',
+          variant: 'destructive',
+        })
+        setIsBooking(false)
+        return
+      }
+
+      if (describeResult.batch_candidate_count > 0) {
+        setStep('batch')
+        setIsBooking(false)
+        onCategorized(transaction.id, result.journal_entry_id || null)
+      } else {
+        toast({ title: 'Bokford', description: 'Transaktion bokford och verifikation skapad' })
+        onCategorized(transaction.id, result.journal_entry_id || null)
+        handleOpenChange(false)
+      }
+    } catch {
+      toast({
+        title: 'Fel',
+        description: 'Nagot gick fel vid bokforing',
+        variant: 'destructive',
+      })
+      setIsBooking(false)
+    }
+  }
+
+  async function handleBatchApply() {
+    if (!describeResult || !selectedTemplateId) return
+
+    setIsBatchApplying(true)
+    try {
+      const response = await fetch('/api/transactions/batch-describe', {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({
+          merchant_name: describeResult.merchant_name,
+          template_id: selectedTemplateId,
+          is_business: true,
+          user_description: describeResult.user_description,
+        }),
+      })
+      const result = await response.json()
+      if (!response.ok) {
+        toast({
+          title: 'Fel',
+          description: result.error || 'Kunde inte bokfora batch',
+          variant: 'destructive',
+        })
+        setIsBatchApplying(false)
+        return
+      }
+
+      const applied = result.data?.applied || 0
+      const errors = result.data?.errors || []
+      if (errors.length > 0) {
+        toast({
+          title: 'Delvis klart',
+          description: `${applied} lyckades, ${errors.length} misslyckades`,
+          variant: 'destructive',
+        })
+      } else {
+        toast({
+          title: 'Klart',
+          description: `${applied} transaktioner bokforda`,
+        })
+      }
+      onBatchApplied?.(applied)
+      handleOpenChange(false)
+    } catch {
+      toast({
+        title: 'Fel',
+        description: 'Nagot gick fel vid batchbokforing',
+        variant: 'destructive',
+      })
+      setIsBatchApplying(false)
+    }
+  }
+
+  function handleSkipBatch() {
+    toast({ title: 'Bokford', description: 'Transaktion bokford och verifikation skapad' })
+    handleOpenChange(false)
+  }
+
+  if (!transaction) return null
+
+  const isIncome = transaction.amount > 0
+
+  return (
+    <Dialog open={open} onOpenChange={(isBooking || isBatchApplying) ? undefined : handleOpenChange}>
+      <DialogContent className="max-w-md max-h-[90vh] flex flex-col">
+        <DialogHeader>
+          <DialogTitle>
+            {step === 'describe' && 'Beskriv transaktion'}
+            {step === 'pick' && 'Valj mall'}
+            {step === 'batch' && 'Bokfor liknande'}
+          </DialogTitle>
+          <DialogDescription>
+            {step === 'describe' && 'Beskriv vad transaktionen galler sa hittar vi ratt bokforingsmall'}
+            {step === 'pick' && 'Valj den mall som stammer bast'}
+            {step === 'batch' && 'Transaktion bokford!'}
+          </DialogDescription>
+        </DialogHeader>
+
+        {/* Transaction summary - shown in describe and pick steps */}
+        {(step === 'describe' || step === 'pick') && (
+          <div className="flex items-center gap-3 rounded-lg border p-3">
+            <div
+              className={`h-9 w-9 rounded-full flex items-center justify-center flex-shrink-0 ${
+                isIncome
+                  ? 'bg-success/10 text-success'
+                  : 'bg-destructive/10 text-destructive'
+              }`}
+            >
+              {isIncome ? (
+                <ArrowUpRight className="h-4 w-4" />
+              ) : (
+                <ArrowDownRight className="h-4 w-4" />
+              )}
+            </div>
+            <div className="flex-1 min-w-0">
+              <p className="font-medium text-sm truncate">{transaction.description}</p>
+              <p className="text-xs text-muted-foreground">{formatDate(transaction.date)}</p>
+            </div>
+            <p className={`font-medium text-sm flex-shrink-0 ${isIncome ? 'text-success' : ''}`}>
+              {isIncome ? '+' : ''}
+              {formatCurrency(transaction.amount, transaction.currency)}
+            </p>
+          </div>
+        )}
+
+        {/* Step 1: Describe */}
+        {step === 'describe' && (
+          <div className="space-y-4">
+            <Textarea
+              placeholder="Beskriv vad transaktionen galler, t.ex. 'lunch med kund' eller 'kontorsmaterial'"
+              value={description}
+              onChange={(e) => setDescription(e.target.value)}
+              rows={3}
+              autoFocus
+              onKeyDown={(e) => {
+                if (e.key === 'Enter' && !e.shiftKey && description.trim().length >= 3) {
+                  e.preventDefault()
+                  handleSearch()
+                }
+              }}
+            />
+            <div className="flex flex-wrap gap-1.5">
+              {getExamplePrompts(transaction).map((prompt) => (
+                <button
+                  key={prompt}
+                  type="button"
+                  className="text-xs px-2.5 py-1 rounded-full border bg-muted/50 hover:bg-muted text-muted-foreground hover:text-foreground transition-colors"
+                  onClick={() => setDescription(prompt)}
+                >
+                  {prompt}
+                </button>
+              ))}
+            </div>
+            <Button
+              className="w-full"
+              disabled={description.trim().length < 3 || isSearching}
+              onClick={handleSearch}
+            >
+              {isSearching ? (
+                <Loader2 className="mr-2 h-4 w-4 animate-spin" />
+              ) : (
+                <Search className="mr-2 h-4 w-4" />
+              )}
+              {isSearching ? 'Soker...' : 'Sok'}
+            </Button>
+          </div>
+        )}
+
+        {/* Step 2: Pick template */}
+        {step === 'pick' && describeResult && (
+          <div className="space-y-4 min-h-0 flex flex-col">
+            {describeResult.needs_more_detail && (
+              <div className="flex items-start gap-2 p-3 rounded-lg bg-amber-500/10 text-amber-700 dark:text-amber-400 text-sm">
+                <AlertTriangle className="h-4 w-4 flex-shrink-0 mt-0.5" />
+                <p>Resultaten ar osakra. Forsok beskriv mer detaljerat for battre traffar.</p>
+              </div>
+            )}
+
+            <div className="overflow-y-auto max-h-[40vh] space-y-2 pr-1">
+              {describeResult.templates.length === 0 ? (
+                <p className="text-sm text-muted-foreground text-center py-4">
+                  Inga matchande mallar hittades. Forsok med en annan beskrivning.
+                </p>
+              ) : (
+                describeResult.templates.map((template) => (
+                  <Card
+                    key={template.template_id}
+                    className={`cursor-pointer transition-colors hover:border-primary/50 ${
+                      selectedTemplateId === template.template_id
+                        ? 'border-primary bg-primary/5'
+                        : ''
+                    }`}
+                    onClick={() => setSelectedTemplateId(template.template_id)}
+                  >
+                    <CardContent className="py-3 px-4">
+                      <div className="flex items-start justify-between gap-2">
+                        <div className="min-w-0 flex-1">
+                          <p className="font-medium text-sm">{template.name_sv}</p>
+                          {template.description_sv && (
+                            <p className="text-xs text-muted-foreground mt-0.5 line-clamp-2">
+                              {template.description_sv}
+                            </p>
+                          )}
+                          <div className="flex flex-wrap items-center gap-1.5 mt-1.5">
+                            <Badge variant="secondary" className="text-[10px] px-1.5 py-0">
+                              D: {formatAccountWithName(template.debit_account)}
+                            </Badge>
+                            <Badge variant="secondary" className="text-[10px] px-1.5 py-0">
+                              K: {formatAccountWithName(template.credit_account)}
+                            </Badge>
+                            {template.vat_treatment && template.vat_treatment !== 'exempt' && (
+                              <Badge variant="outline" className="text-[10px] px-1.5 py-0">
+                                Moms {Math.round(template.vat_rate * 100)}%
+                              </Badge>
+                            )}
+                            {template.vat_treatment === 'exempt' && (
+                              <Badge variant="outline" className="text-[10px] px-1.5 py-0">
+                                Momsfritt
+                              </Badge>
+                            )}
+                            {template.deductibility === 'non_deductible' && (
+                              <Badge variant="outline" className="text-[10px] px-1.5 py-0 text-amber-600 border-amber-300">
+                                Ej avdragsgill
+                              </Badge>
+                            )}
+                            {template.deductibility === 'conditional' && (
+                              <Badge variant="outline" className="text-[10px] px-1.5 py-0 text-amber-600 border-amber-300">
+                                Villkorligt avdrag
+                              </Badge>
+                            )}
+                          </div>
+                          {(template.deductibility_note_sv || template.special_rules_sv) && selectedTemplateId === template.template_id && (
+                            <div className="mt-2 space-y-1">
+                              {template.deductibility_note_sv && (
+                                <p className="text-[11px] text-amber-600 dark:text-amber-400">
+                                  {template.deductibility_note_sv}
+                                </p>
+                              )}
+                              {template.special_rules_sv && (
+                                <p className="text-[11px] text-muted-foreground italic">
+                                  {template.special_rules_sv}
+                                </p>
+                              )}
+                            </div>
+                          )}
+                        </div>
+                        <div className="flex items-center gap-2 flex-shrink-0">
+                          <Badge
+                            variant={template.confidence >= 0.7 ? 'default' : 'outline'}
+                            className="text-[10px] px-1.5 py-0"
+                          >
+                            {Math.round(template.confidence * 100)}%
+                          </Badge>
+                          {selectedTemplateId === template.template_id && (
+                            <Check className="h-4 w-4 text-primary" />
+                          )}
+                        </div>
+                      </div>
+                    </CardContent>
+                  </Card>
+                ))
+              )}
+            </div>
+
+            {/* Journal entry preview for selected template */}
+            {selectedTemplateId && (() => {
+              const tmpl = describeResult.templates.find(t => t.template_id === selectedTemplateId)
+              if (!tmpl) return null
+              return (
+                <JournalEntryPreview
+                  amount={transaction.amount}
+                  currency={transaction.currency}
+                  templateDebitAccount={tmpl.debit_account}
+                  templateCreditAccount={tmpl.credit_account}
+                  templateVatRate={tmpl.vat_rate}
+                />
+              )
+            })()}
+
+            <div className="flex gap-2 pt-2">
+              <Button
+                variant="ghost"
+                className="flex-shrink-0"
+                onClick={() => {
+                  setStep('describe')
+                  setSelectedTemplateId(null)
+                }}
+              >
+                <ArrowLeft className="mr-2 h-4 w-4" />
+                Beskriv igen
+              </Button>
+              <Button
+                className="flex-1"
+                disabled={!selectedTemplateId || isBooking}
+                onClick={handleBook}
+              >
+                {isBooking ? (
+                  <Loader2 className="mr-2 h-4 w-4 animate-spin" />
+                ) : (
+                  <Check className="mr-2 h-4 w-4" />
+                )}
+                {isBooking ? 'Bokfor...' : 'Bokfor'}
+              </Button>
+            </div>
+          </div>
+        )}
+
+        {/* Step 3: Batch offer */}
+        {step === 'batch' && describeResult && (
+          <div className="space-y-4">
+            <div className="flex items-center gap-3 p-4 rounded-lg bg-success/10">
+              <CheckCircle2 className="h-6 w-6 text-success flex-shrink-0" />
+              <p className="text-sm font-medium">Transaktionen ar bokford!</p>
+            </div>
+
+            <p className="text-sm text-muted-foreground">
+              Det finns ytterligare{' '}
+              <span className="font-medium text-foreground">
+                {describeResult.batch_candidate_count}
+              </span>{' '}
+              obokforda transaktioner fran{' '}
+              <span className="font-medium text-foreground">
+                {describeResult.merchant_name}
+              </span>
+              . Anvand samma mall?
+            </p>
+
+            <div className="flex gap-2">
+              <Button
+                variant="outline"
+                className="flex-1"
+                onClick={handleSkipBatch}
+                disabled={isBatchApplying}
+              >
+                Nej, bara den har
+              </Button>
+              <Button
+                className="flex-1"
+                onClick={handleBatchApply}
+                disabled={isBatchApplying}
+              >
+                {isBatchApplying ? (
+                  <Loader2 className="mr-2 h-4 w-4 animate-spin" />
+                ) : null}
+                {isBatchApplying
+                  ? 'Bokfor...'
+                  : `Ja, bokfor alla ${describeResult.batch_candidate_count} st`}
+              </Button>
+            </div>
+          </div>
+        )}
+      </DialogContent>
+    </Dialog>
+  )
+}

components/transactions/InvoiceMatchDialog.tsx

@@ -3,6 +3,7 @@
 import { Button } from '@/components/ui/button'
 import { Dialog, DialogContent, DialogHeader, DialogTitle, DialogDescription, DialogFooter } from '@/components/ui/dialog'
 import { formatCurrency, formatDate } from '@/lib/utils'
+import { CheckCircle2, AlertTriangle } from 'lucide-react'
 import type { TransactionWithInvoice } from './transaction-types'
 
 interface InvoiceMatchDialogProps {
@@ -66,6 +67,37 @@ export default function InvoiceMatchDialog({
               </div>
             </div>
 
+            {/* Amount comparison */}
+            {(() => {
+              const txAmount = transaction.amount
+              const invAmount = transaction.potential_invoice!.total
+              const sameCurrency = transaction.currency === transaction.potential_invoice!.currency
+              const amountsMatch = sameCurrency && Math.abs(txAmount - invAmount) < 0.01
+
+              if (amountsMatch) {
+                return (
+                  <div className="flex items-center gap-2 p-3 rounded-lg bg-success/10 text-success">
+                    <CheckCircle2 className="h-4 w-4 flex-shrink-0" />
+                    <p className="text-sm font-medium">Beloppen stammer</p>
+                  </div>
+                )
+              }
+
+              const diff = Math.abs(txAmount - invAmount)
+              return (
+                <div className="flex items-start gap-2 p-3 rounded-lg bg-amber-500/10 text-amber-700 dark:text-amber-400">
+                  <AlertTriangle className="h-4 w-4 flex-shrink-0 mt-0.5" />
+                  <div className="text-sm">
+                    <p className="font-medium">Beloppen skiljer sig</p>
+                    <p>
+                      Differens: {formatCurrency(diff, transaction.currency)}
+                      {!sameCurrency && ' (olika valutor)'}
+                    </p>
+                  </div>
+                </div>
+              )
+            })()}
+
             {/* What will happen */}
             <div className="rounded-lg bg-muted/50 p-4 space-y-2">
               <p className="text-sm font-medium">Vid bekräftelse:</p>

components/transactions/JournalEntryPreview.tsx

@@ -0,0 +1,114 @@
+'use client'
+
+import { useMemo } from 'react'
+import { formatCurrency } from '@/lib/utils'
+import { formatAccountWithName } from '@/lib/bookkeeping/client-account-names'
+import { getVatRate, extractVatAmount, extractNetAmount } from '@/lib/bookkeeping/vat-entries'
+import { getCategoryAccountMapping } from '@/lib/bookkeeping/category-mapping'
+import type { TransactionCategory, VatTreatment } from '@/types'
+
+interface PreviewLine {
+  side: 'debet' | 'kredit'
+  account: string
+  amount: number
+}
+
+interface JournalEntryPreviewProps {
+  amount: number
+  currency?: string
+  category?: TransactionCategory
+  vatTreatment?: VatTreatment | 'none'
+  accountOverride?: string
+  /** For template-based bookings — overrides category mapping */
+  templateDebitAccount?: string
+  templateCreditAccount?: string
+  templateVatRate?: number
+}
+
+export default function JournalEntryPreview({
+  amount,
+  currency = 'SEK',
+  category,
+  vatTreatment,
+  accountOverride,
+  templateDebitAccount,
+  templateCreditAccount,
+  templateVatRate,
+}: JournalEntryPreviewProps) {
+  const lines = useMemo(() => {
+    const result: PreviewLine[] = []
+    const absAmount = Math.abs(amount)
+
+    // Template-based preview
+    if (templateDebitAccount && templateCreditAccount) {
+      const vatRate = templateVatRate ?? 0
+      const vatAmt = extractVatAmount(absAmount, vatRate)
+      const netAmt = extractNetAmount(absAmount, vatRate)
+
+      result.push({ side: 'debet', account: templateDebitAccount, amount: netAmt })
+      if (vatAmt > 0) {
+        result.push({ side: 'debet', account: '2641', amount: vatAmt })
+      }
+      result.push({ side: 'kredit', account: templateCreditAccount, amount: absAmount })
+      return result
+    }
+
+    // Category-based preview
+    if (!category) return result
+
+    const resolvedVat = vatTreatment === 'none' ? undefined : vatTreatment
+    const mapping = getCategoryAccountMapping(category, amount, category !== 'private', 'enskild_firma', resolvedVat)
+
+    const debitAccount = accountOverride && amount < 0 ? accountOverride : mapping.debitAccount
+    const creditAccount = accountOverride && amount > 0 ? accountOverride : mapping.creditAccount
+
+    const treatment = mapping.vatTreatment as VatTreatment | null
+    const vatRate = treatment ? getVatRate(treatment) : 0
+    const vatAmt = vatRate > 0 ? extractVatAmount(absAmount, vatRate) : 0
+    const netAmt = vatRate > 0 ? extractNetAmount(absAmount, vatRate) : absAmount
+
+    if (amount < 0) {
+      // Expense: Debit expense + VAT, Credit bank
+      result.push({ side: 'debet', account: debitAccount, amount: netAmt })
+      if (vatAmt > 0 && mapping.vatDebitAccount) {
+        result.push({ side: 'debet', account: mapping.vatDebitAccount, amount: vatAmt })
+      }
+      result.push({ side: 'kredit', account: creditAccount, amount: absAmount })
+    } else {
+      // Income: Debit bank, Credit revenue + VAT
+      result.push({ side: 'debet', account: debitAccount, amount: absAmount })
+      if (vatAmt > 0 && mapping.vatCreditAccount) {
+        result.push({ side: 'kredit', account: mapping.vatCreditAccount, amount: vatAmt })
+      }
+      result.push({ side: 'kredit', account: creditAccount, amount: netAmt })
+    }
+
+    // Reverse charge: add offsetting lines
+    if (treatment === 'reverse_charge' && amount < 0) {
+      const rcVatAmt = Math.round(absAmount * 0.25 * 100) / 100
+      result.push({ side: 'debet', account: '2645', amount: rcVatAmt })
+      result.push({ side: 'kredit', account: '2614', amount: rcVatAmt })
+    }
+
+    return result
+  }, [amount, category, vatTreatment, accountOverride, templateDebitAccount, templateCreditAccount, templateVatRate])
+
+  if (lines.length === 0) return null
+
+  return (
+    <div className="rounded-lg border bg-muted/30 px-3 py-2.5">
+      <p className="text-xs font-medium text-muted-foreground mb-1.5">Verifikation</p>
+      <div className="space-y-0.5 font-mono text-xs">
+        {lines.map((line, i) => (
+          <div key={i} className="flex items-baseline gap-2">
+            <span className={`w-12 text-right flex-shrink-0 ${line.side === 'debet' ? 'text-foreground' : 'text-muted-foreground'}`}>
+              {line.side === 'debet' ? 'Debet' : 'Kredit'}
+            </span>
+            <span className="flex-1 truncate">{formatAccountWithName(line.account)}</span>
+            <span className="flex-shrink-0 tabular-nums">{formatCurrency(line.amount, currency)}</span>
+          </div>
+        ))}
+      </div>
+    </div>
+  )
+}

components/transactions/QuickReviewDialog.tsx

@@ -8,10 +8,12 @@ import { useToast } from '@/components/ui/use-toast'
 import { formatCurrency, formatDate } from '@/lib/utils'
 import { ArrowUpRight, ArrowDownRight, Check, Paperclip, ChevronDown, ChevronUp } from 'lucide-react'
 import { getDefaultAccountForCategory } from '@/lib/bookkeeping/category-mapping'
+import JournalEntryPreview from './JournalEntryPreview'
 import AccountCombobox from '@/components/bookkeeping/AccountCombobox'
 import DocumentUploadZone from '@/components/bookkeeping/DocumentUploadZone'
 import type { UploadedFile } from '@/components/bookkeeping/DocumentUploadZone'
 import VatTreatmentSelect from './VatTreatmentSelect'
+import { VAT_TREATMENT_OPTIONS } from './transaction-types'
 import type { TransactionWithInvoice } from './transaction-types'
 import type { TransactionCategory, VatTreatment, BASAccount } from '@/types'
 
@@ -49,6 +51,7 @@ export default function QuickReviewDialog({
   const [error, setError] = useState<string | null>(null)
   const [uploadedFiles, setUploadedFiles] = useState<UploadedFile[]>([])
   const [showUploadZone, setShowUploadZone] = useState(false)
+  const [showVatDropdown, setShowVatDropdown] = useState(false)
 
   // Handle account changes — clear VAT for liability/equity accounts (class 2)
   const handleAccountChange = useCallback((account: string) => {
@@ -174,6 +177,15 @@ export default function QuickReviewDialog({
           </div>
         </div>
 
+        {/* Journal entry preview */}
+        <JournalEntryPreview
+          amount={transaction.amount}
+          currency={transaction.currency}
+          category={category}
+          vatTreatment={isLiabilityAccount ? 'none' : vatTreatment}
+          accountOverride={accountOverride}
+        />
+
         {/* Account */}
         <div>
           <label className="text-sm font-medium text-muted-foreground">Konto</label>
@@ -190,14 +202,26 @@ export default function QuickReviewDialog({
         <div>
           <label className="text-sm font-medium text-muted-foreground">Momsbehandling</label>
           <div className="mt-1">
-            <VatTreatmentSelect
-              value={isLiabilityAccount ? 'none' : vatTreatment}
-              onValueChange={setVatTreatment}
-              disabled={isLiabilityAccount}
-            />
-            {isLiabilityAccount && (
-              <p className="text-xs text-muted-foreground mt-1">
-                Ingen moms för skuld-/eget kapital-konton
+            {isLiabilityAccount ? (
+              <p className="text-sm text-muted-foreground">
+                Ingen moms for skuld-/eget kapital-konton
+              </p>
+            ) : showVatDropdown ? (
+              <VatTreatmentSelect
+                value={vatTreatment}
+                onValueChange={setVatTreatment}
+              />
+            ) : (
+              <p className="text-sm">
+                {VAT_TREATMENT_OPTIONS.find(o => o.value === vatTreatment)?.label || 'Ingen moms'}
+                {' '}
+                <button
+                  type="button"
+                  className="text-xs text-primary hover:underline"
+                  onClick={() => setShowVatDropdown(true)}
+                >
+                  Andra
+                </button>
               </p>
             )}
           </div>

components/transactions/SwipeCategorizationView.tsx

@@ -10,18 +10,22 @@ import VatTreatmentSelect from './VatTreatmentSelect'
 import { formatCurrency, formatDate } from '@/lib/utils'
 import { checkExpenseWarnings } from '@/lib/tax/expense-warnings'
 import { getDefaultAccountForCategory, getDefaultVatTreatmentForCategory } from '@/lib/bookkeeping/category-mapping'
+import JournalEntryPreview from './JournalEntryPreview'
 import AccountCombobox from '@/components/bookkeeping/AccountCombobox'
 import DocumentUploadZone from '@/components/bookkeeping/DocumentUploadZone'
 import type { UploadedFile } from '@/components/bookkeeping/DocumentUploadZone'
-import { X, ArrowLeft, ArrowRight, Building, AlertTriangle, Check, FileText, Link2, Receipt as ReceiptIcon, SkipForward, Paperclip, ChevronDown, ChevronUp } from 'lucide-react'
+import { X, ArrowLeft, ArrowRight, Building, AlertTriangle, Check, FileText, Link2, Receipt as ReceiptIcon, SkipForward, Paperclip, ChevronDown, ChevronUp, MessageSquareText } from 'lucide-react'
+import DescribeTransactionDialog from './DescribeTransactionDialog'
+import { formatAccountWithName } from '@/lib/bookkeeping/client-account-names'
 import type { TransactionCategory, VatTreatment, BASAccount } from '@/types'
-import type { SuggestedCategory } from '@/lib/transactions/category-suggestions'
+import type { SuggestedCategory, SuggestedTemplate } from '@/lib/transactions/category-suggestions'
 import type { TransactionWithInvoice, CategorizeHandler, MatchInvoiceHandler } from './transaction-types'
-import { EXPENSE_CATEGORIES, INCOME_CATEGORIES } from './transaction-types'
+import { EXPENSE_CATEGORIES, INCOME_CATEGORIES, VAT_TREATMENT_OPTIONS } from './transaction-types'
 
 interface SwipeCategorizationViewProps {
   transactions: TransactionWithInvoice[]
   suggestions?: Record<string, SuggestedCategory[]>
+  templateSuggestions?: Record<string, SuggestedTemplate[]>
   onCategorize: CategorizeHandler
   onMatchInvoice?: MatchInvoiceHandler
   onClose: () => void
@@ -33,6 +37,7 @@ const incomeCategories = INCOME_CATEGORIES
 export default function SwipeCategorizationView({
   transactions,
   suggestions,
+  templateSuggestions,
   onCategorize,
   onMatchInvoice,
   onClose,
@@ -52,6 +57,8 @@ export default function SwipeCategorizationView({
   const [accounts, setAccounts] = useState<BASAccount[]>([])
   const [uploadedFiles, setUploadedFiles] = useState<UploadedFile[]>([])
   const [showUploadZone, setShowUploadZone] = useState(false)
+  const [showDescribeDialog, setShowDescribeDialog] = useState(false)
+  const [showVatDropdown, setShowVatDropdown] = useState(false)
 
   // Clear VAT treatment when switching to a liability/equity account (class 2)
   useEffect(() => {
@@ -113,6 +120,7 @@ export default function SwipeCategorizationView({
     setPendingCategory(category)
     setAccountOverride(defaultAccount)
     setVatTreatment(defaultVat ?? 'none')
+    setShowVatDropdown(false)
     setShowCategorySelect(false)
     setShowReviewStep(true)
     setError(null)
@@ -366,6 +374,15 @@ export default function SwipeCategorizationView({
             </div>
           </div>
 
+          {/* Journal entry preview */}
+          <JournalEntryPreview
+            amount={currentTransaction.amount}
+            currency={currentTransaction.currency}
+            category={pendingCategory}
+            vatTreatment={isLiabilityAccount ? 'none' : vatTreatment}
+            accountOverride={accountOverride}
+          />
+
           {/* Account override */}
           <div>
             <label className="text-sm font-medium text-muted-foreground">Konto</label>
@@ -382,15 +399,27 @@ export default function SwipeCategorizationView({
           <div>
             <label className="text-sm font-medium text-muted-foreground">Momsbehandling</label>
             <div className="mt-1">
-              <VatTreatmentSelect
-                value={isLiabilityAccount ? 'none' : vatTreatment}
-                onValueChange={setVatTreatment}
-                disabled={isLiabilityAccount}
-              />
-              {isLiabilityAccount && (
-                <p className="text-xs text-muted-foreground mt-1">
+              {isLiabilityAccount ? (
+                <p className="text-sm text-muted-foreground">
                   Ingen moms for skuld-/eget kapital-konton
                 </p>
+              ) : showVatDropdown ? (
+                <VatTreatmentSelect
+                  value={vatTreatment}
+                  onValueChange={setVatTreatment}
+                />
+              ) : (
+                <p className="text-sm">
+                  {VAT_TREATMENT_OPTIONS.find(o => o.value === vatTreatment)?.label || 'Ingen moms'}
+                  {' '}
+                  <button
+                    type="button"
+                    className="text-xs text-primary hover:underline"
+                    onClick={() => setShowVatDropdown(true)}
+                  >
+                    Andra
+                  </button>
+                </p>
               )}
             </div>
           </div>
@@ -641,7 +670,7 @@ export default function SwipeCategorizationView({
                     <div className="flex flex-col">
                       <span className="text-sm font-medium">{suggestion.label}</span>
                       {suggestion.account && (
-                        <span className="text-xs text-muted-foreground">{suggestion.account}</span>
+                        <span className="text-xs text-muted-foreground">{formatAccountWithName(suggestion.account)}</span>
                       )}
                     </div>
                   </Button>
@@ -650,6 +679,45 @@ export default function SwipeCategorizationView({
             </div>
           )}
 
+          {/* Fallback templates when no strong suggestion */}
+          {(() => {
+            const txSuggestions = suggestions?.[currentTransaction.id]
+            const topConfidence = txSuggestions?.[0]?.confidence ?? 0
+            const templates = templateSuggestions?.[currentTransaction.id]
+            if (topConfidence < 0.55 && templates && templates.length > 0) {
+              return (
+                <div className="space-y-2">
+                  <p className="text-xs text-muted-foreground text-center">Osaker? Prova dessa mallar:</p>
+                  <div className="grid grid-cols-2 gap-2">
+                    {templates.slice(0, 3).map((tmpl) => (
+                      <Button
+                        key={tmpl.template_id}
+                        variant="outline"
+                        className="h-auto py-2.5 px-3 text-left justify-start border-dashed"
+                        onClick={() => setShowDescribeDialog(true)}
+                        disabled={isProcessing}
+                      >
+                        <span className="text-sm">{tmpl.name_sv}</span>
+                      </Button>
+                    ))}
+                  </div>
+                </div>
+              )
+            }
+            return null
+          })()}
+
+          {/* Describe transaction button */}
+          <Button
+            variant="outline"
+            className="w-full"
+            onClick={() => setShowDescribeDialog(true)}
+            disabled={isProcessing}
+          >
+            <MessageSquareText className="mr-2 h-4 w-4" />
+            Beskriv transaktion...
+          </Button>
+
           {/* Categorization button */}
           <Button
             className="w-full"
@@ -678,6 +746,20 @@ export default function SwipeCategorizationView({
           </Button>
         </div>
       </div>
+
+      <DescribeTransactionDialog
+        open={showDescribeDialog}
+        onOpenChange={setShowDescribeDialog}
+        transaction={currentTransaction}
+        onCategorized={() => {
+          setShowDescribeDialog(false)
+          moveToNext()
+        }}
+        onBatchApplied={() => {
+          setShowDescribeDialog(false)
+          moveToNext()
+        }}
+      />
     </div>
   )
 }

components/transactions/TransactionInboxCard.tsx

@@ -6,14 +6,16 @@ import { Button } from '@/components/ui/button'
 import { Badge } from '@/components/ui/badge'
 import { Checkbox } from '@/components/ui/checkbox'
 import { formatCurrency, formatDate } from '@/lib/utils'
-import { ArrowUpRight, ArrowDownRight, FileText, Loader2 } from 'lucide-react'
+import { ArrowUpRight, ArrowDownRight, FileText, Loader2, MessageSquareText } from 'lucide-react'
 import { Tooltip, TooltipTrigger, TooltipContent, TooltipProvider } from '@/components/ui/info-tooltip'
+import { formatAccountWithName } from '@/lib/bookkeeping/client-account-names'
 import type { TransactionWithInvoice, CategorizeHandler } from './transaction-types'
-import type { SuggestedCategory } from '@/lib/transactions/category-suggestions'
+import type { SuggestedCategory, SuggestedTemplate } from '@/lib/transactions/category-suggestions'
 
 interface TransactionInboxCardProps {
   transaction: TransactionWithInvoice
   suggestions?: SuggestedCategory[]
+  templateSuggestions?: SuggestedTemplate[]
   processingId: string | null
   isBatchMode: boolean
   isSelected: boolean
@@ -22,6 +24,7 @@ interface TransactionInboxCardProps {
   onMarkPrivate: (id: string) => void
   onOpenMatchDialog: (transaction: TransactionWithInvoice) => void
   onOpenCategoryDialog: (transaction: TransactionWithInvoice) => void
+  onOpenDescribe?: (transaction: TransactionWithInvoice) => void
   onOpenQuickReview?: (transaction: TransactionWithInvoice, suggestion: SuggestedCategory) => void
   onToggleSelect: (id: string) => void
   onAnimationComplete?: (id: string) => void
@@ -30,6 +33,7 @@ interface TransactionInboxCardProps {
 export default function TransactionInboxCard({
   transaction,
   suggestions,
+  templateSuggestions,
   processingId,
   isBatchMode,
   isSelected,
@@ -38,6 +42,7 @@ export default function TransactionInboxCard({
   onMarkPrivate,
   onOpenMatchDialog,
   onOpenCategoryDialog,
+  onOpenDescribe,
   onOpenQuickReview,
   onToggleSelect,
   onAnimationComplete,
@@ -49,6 +54,8 @@ export default function TransactionInboxCard({
   const topSuggestion = suggestions?.[0]
   const isUncategorized = transaction.is_business === null && !transaction.journal_entry_id
   const showCheckbox = isBatchMode && isUncategorized
+  const hasWeakSuggestions = !topSuggestion || topSuggestion.confidence < 0.55
+  const showTemplateFallback = hasWeakSuggestions && templateSuggestions && templateSuggestions.length > 0
 
   function handleSuggestionClick(suggestion: SuggestedCategory) {
     if (onOpenQuickReview) {
@@ -155,6 +162,11 @@ export default function TransactionInboxCard({
                     <Loader2 className="mr-1.5 h-3 w-3 animate-spin" />
                   ) : null}
                   {topSuggestion.label}
+                  {topSuggestion.account && (
+                    <span className="ml-1 text-muted-foreground font-normal">
+                      ({formatAccountWithName(topSuggestion.account)})
+                    </span>
+                  )}
                   {topSuggestion.confidence >= 0.8 && (
                     <Badge variant="secondary" className="ml-1.5 text-[10px] px-1 py-0">
                       {Math.round(topSuggestion.confidence * 100)}%
@@ -173,9 +185,33 @@ export default function TransactionInboxCard({
                   disabled={isProcessing || isDisabled}
                 >
                   {suggestions[1].label}
+                  {suggestions[1].account && (
+                    <span className="ml-1 text-muted-foreground font-normal">
+                      ({formatAccountWithName(suggestions[1].account)})
+                    </span>
+                  )}
                 </Button>
               )}
 
+              {/* Fallback templates when no strong suggestion */}
+              {showTemplateFallback && !hasInvoiceMatch && (
+                <>
+                  <span className="text-[10px] text-muted-foreground">Osaker? Prova:</span>
+                  {templateSuggestions!.slice(0, 3).map((tmpl) => (
+                    <Button
+                      key={tmpl.template_id}
+                      size="sm"
+                      variant="outline"
+                      className="h-8 text-xs border-dashed"
+                      onClick={() => onOpenDescribe?.(transaction)}
+                      disabled={isProcessing || isDisabled}
+                    >
+                      {tmpl.name_sv}
+                    </Button>
+                  ))}
+                </>
+              )}
+
               {/* Private button */}
               <TooltipProvider delayDuration={300}>
                 <Tooltip>
@@ -200,6 +236,20 @@ export default function TransactionInboxCard({
                 </Tooltip>
               </TooltipProvider>
 
+              {/* Describe transaction */}
+              {onOpenDescribe && (
+                <Button
+                  size="sm"
+                  variant="outline"
+                  className="h-8 text-xs"
+                  onClick={() => onOpenDescribe(transaction)}
+                  disabled={isProcessing || isDisabled}
+                >
+                  <MessageSquareText className="mr-1.5 h-3 w-3" />
+                  Beskriv...
+                </Button>
+              )}
+
               {/* Open category dialog */}
               <Button
                 size="sm"

components/transactions/transaction-types.ts

@@ -32,10 +32,14 @@ export interface CategoryOption {
 
 // Shared category arrays
 export const EXPENSE_CATEGORIES: CategoryOption[] = [
+  { value: 'expense_representation', label: 'Representation' },
   { value: 'expense_equipment', label: 'Utrustning' },
   { value: 'expense_software', label: 'Programvara' },
+  { value: 'expense_consumables', label: 'Material' },
   { value: 'expense_travel', label: 'Resor' },
   { value: 'expense_office', label: 'Kontor' },
+  { value: 'expense_vehicle', label: 'Bil & drivmedel' },
+  { value: 'expense_telecom', label: 'Telefon & internet' },
   { value: 'expense_marketing', label: 'Marknadsföring' },
   { value: 'expense_professional_services', label: 'Konsulter' },
   { value: 'expense_education', label: 'Utbildning' },

extensions/general/ai-categorization/categorizer.ts

@@ -87,14 +87,32 @@ function getCategoryAccountMap(entityType: EntityType): Record<string, { account
     expense_marketing: { account: '5910', label: 'Annonsering/marknadsföring' },
     expense_professional_services: { account: '6530', label: 'Redovisning/konsulttjänster' },
     expense_education: { account: educationAccount, label: 'Utbildning' },
+    expense_representation: { account: '6071', label: 'Representation (mat/möte)' },
+    expense_consumables: { account: '5460', label: 'Förbrukningsvaror' },
+    expense_vehicle: { account: '5611', label: 'Bil & drivmedel' },
+    expense_telecom: { account: '6200', label: 'Telefon & internet' },
     expense_bank_fees: { account: '6570', label: 'Bankavgifter' },
     expense_card_fees: { account: '6570', label: 'Kortavgifter' },
     expense_currency_exchange: { account: '7960', label: 'Valutakursförluster' },
     expense_other: { account: '6991', label: 'Övriga kostnader' },
-    private: { account: '2013', label: 'Privat uttag (EF) / Skuld till ägare (AB)' },
   }
 }
 
+/** Fallback template IDs when AI doesn't provide one */
+const CATEGORY_DEFAULT_TEMPLATES: Record<string, string> = {
+  expense_representation: 'representation_external',
+  expense_equipment: 'equipment_tools',
+  expense_software: 'software_subscription',
+  expense_travel: 'travel_domestic',
+  expense_office: 'office_supplies_general',
+  expense_consumables: 'office_supplies_general',
+  expense_vehicle: 'travel_fuel',
+  expense_telecom: 'telecom_mobile',
+  expense_marketing: 'marketing_advertising',
+  expense_education: 'education_course',
+  expense_professional_services: 'consulting_accounting',
+}
+
 /**
  * Build template reference from candidate templates (pre-filtered by embeddings)
  * or fall back to full template list if no candidates provided.
@@ -114,12 +132,8 @@ function getTemplateReference(
 }
 
 const NON_DEDUCTIBLE_RULES = `
-ICKE-AVDRAGSGILLA KOSTNADER (svensk skatterätt):
-- Kläder: Normalt inte avdragsgilla (RÅ 1988 ref. 35)
-- Gym/träning: Inte avdragsgilla som personlig kostnad (IL 9 kap 2§)
-- Kosmetika/hudvård: Normalt inte avdragsgillt
-- Frisör: Normalt privat kostnad
-- Representation/måltider: Max 300 kr/person exkl. moms (IL 16 kap 2§)
+MOMSREGLER FÖR SPECIFIKA KATEGORIER:
+- Representation/måltider: Max 300 kr/person exkl. moms (IL 16 kap 2§), konto 6071/6072
 - Gåvor: Reklamgåvor max 300 kr/mottagare, representationsgåvor max 180 kr
 - Telefon/dator vid blandad användning: Bara yrkesmässig del avdragsgill
 `
@@ -140,15 +154,15 @@ const CLASSIFY_TOOL: Anthropic.Tool = {
           type: 'object',
           properties: {
             transactionId: { type: 'string', description: 'Transaction ID' },
-            templateId: { type: 'string', description: 'Booking template ID (from the provided templates list)' },
-            category: { type: 'string', description: 'Transaction category (e.g. expense_software, income_services, private)' },
+            templateId: { type: 'string', description: 'Booking template ID (REQUIRED — must be from the provided templates list)' },
+            category: { type: 'string', description: 'Transaction category (e.g. expense_representation, expense_equipment, expense_office)' },
             basAccount: { type: 'string', description: 'BAS account number (4 digits)' },
             taxCode: { type: ['string', 'null'], description: 'Tax code: MPI for deductible expenses with VAT, MP1 for income with VAT, null for VAT-exempt/private' },
             confidence: { type: 'number', description: 'Confidence score 0.0-1.0' },
             reasoning: { type: 'string', description: 'Short reasoning in Swedish' },
             isPrivate: { type: 'boolean', description: 'Whether this is a private expense' },
           },
-          required: ['transactionId', 'category', 'basAccount', 'confidence', 'reasoning', 'isPrivate'],
+          required: ['transactionId', 'templateId', 'category', 'basAccount', 'confidence', 'reasoning', 'isPrivate'],
         },
       },
     },
@@ -232,12 +246,14 @@ ${NON_DEDUCTIBLE_RULES}
 
 REGLER:
 1. Negativa belopp = utgifter, positiva = intäkter
-2. Markera transaktioner som troligen är privata med isPrivate: true
-3. Ange confidence 0.0-1.0 baserat på hur säker du är
+2. VIKTIGT: Dessa transaktioner kommer från företagets bankkonto/kort. Anta ALLTID att de är affärsrelaterade. Klassificera ALDRIG som "private" — det beslutet tar användaren själv.
+3. Ange confidence 0.0-1.0 baserat på hur säker du är på rätt affärskategori
 4. Ange kort reasoning på svenska
-5. Om en transaktion liknar privat konsumtion (kläder, gym, etc.), sätt category: "private"
-6. taxCode: "MPI" för avdragsgilla affärskostnader med moms, "MP1" för intäkter med moms, null för momsfria/privata
-7. Ange templateId om en bokföringsmall matchar (föredra mallar framför generiska kategorier)`
+5. Restauranger/mat/café → expense_representation (6071). Bygghandel/järnhandel → expense_equipment eller expense_consumables. Heminredning/kontorsvaror → expense_office.
+6. taxCode: "MPI" för avdragsgilla affärskostnader med moms, "MP1" för intäkter med moms, null för momsfria
+7. templateId är OBLIGATORISKT — välj alltid den mest passande mallen från listan ovan, även för alternativa förslag
+8. isPrivate ska ALLTID vara false — användaren avgör själv vad som är privat
+9. Ange TVÅ förslag per transaktion: ett primärt (mest troligt) och ett alternativt (näst mest troligt, annan kategori, lägre confidence). Båda ska vara affärskategorier.`
 
     const historyContext =
       context.recentHistory.length > 0
@@ -257,7 +273,8 @@ REGLER:
       )
       .join('\n\n')
 
-    const userPrompt = `Kategorisera följande transaktioner med classify_transactions-verktyget:
+    const userPrompt = `Kategorisera följande transaktioner med classify_transactions-verktyget.
+Ange TVÅ förslag per transaktion (primärt + alternativ med lägre confidence):
 ${historyContext}${accountUsageContext}${merchantHistoryContext}
 
 TRANSAKTIONER:
@@ -322,6 +339,7 @@ ${transactionList}`
     const categoryAccountMap = getCategoryAccountMap(entityType)
     const validTransactionIds = new Set(transactions.map((t) => t.id))
     const validCategories = new Set(Object.keys(categoryAccountMap).concat(['uncategorized']))
+    const transactionMap = new Map(transactions.map((t) => [t.id, t]))
 
     return raw
       .filter(
@@ -330,9 +348,23 @@ ${transactionList}`
       )
       .filter((s) => validTransactionIds.has(s.transactionId as string))
       .map((s) => {
-        const category = validCategories.has(s.category as string)
+        // Never let AI classify as private — remap to expense_other
+        let category = validCategories.has(s.category as string)
           ? (s.category as TransactionCategory)
           : 'expense_other'
+        if (category === 'private') {
+          category = 'expense_other'
+        }
+
+        // Enforce direction: positive amounts = income, negative = expense
+        const tx = transactionMap.get(s.transactionId as string)
+        if (tx) {
+          if (tx.amount > 0 && category.startsWith('expense_')) {
+            category = 'income_other' as TransactionCategory
+          } else if (tx.amount < 0 && category.startsWith('income_')) {
+            category = 'expense_other' as TransactionCategory
+          }
+        }
 
         const accountInfo = categoryAccountMap[category]
 
@@ -343,8 +375,8 @@ ${transactionList}`
           taxCode: (s.taxCode as string) || null,
           confidence: Math.max(0, Math.min(1, Number(s.confidence) || 0.5)),
           reasoning: (s.reasoning as string) || '',
-          isPrivate: category === 'private' || Boolean(s.isPrivate),
-          templateId: (s.templateId as string) || undefined,
+          isPrivate: false,
+          templateId: (s.templateId as string) || CATEGORY_DEFAULT_TEMPLATES[category] || undefined,
         }
       })
   }

extensions/general/ai-categorization/index.ts

@@ -323,16 +323,28 @@ async function storeSuggestions(
   // eslint-disable-next-line @typescript-eslint/no-explicit-any
   supabase: any
 ): Promise<void> {
+  // Group suggestions by transactionId (AI now returns multiple per transaction)
+  const grouped: Record<string, CategorizationSuggestion[]> = {}
   for (const suggestion of suggestions) {
-    await supabase.from('extension_data').upsert(
+    if (!grouped[suggestion.transactionId]) {
+      grouped[suggestion.transactionId] = []
+    }
+    grouped[suggestion.transactionId].push(suggestion)
+  }
+
+  for (const [txId, txSuggestions] of Object.entries(grouped)) {
+    const { error } = await supabase.from('extension_data').upsert(
       {
         user_id: userId,
         extension_id: 'ai-categorization',
-        key: `suggestion:${suggestion.transactionId}`,
-        value: suggestion,
+        key: `suggestion:${txId}`,
+        value: txSuggestions,
       },
       { onConflict: 'user_id,extension_id,key' }
     )
+    if (error) {
+      console.error(`[ai-categorization] Failed to store suggestion for ${txId}:`, error.message)
+    }
   }
 }
 

extensions/general/receipt-ocr/lib/receipt-categorizer.ts

@@ -28,6 +28,10 @@ const BAS_ACCOUNT_MAPPING: Record<TransactionCategory, string> = {
   expense_marketing: '5910', // Annonsering
   expense_professional_services: '6530', // Redovisningstjänster
   expense_education: '6991', // Övriga avdragsgilla kostnader
+  expense_representation: '6071', // Representation
+  expense_consumables: '5460', // Förbrukningsvaror
+  expense_vehicle: '5611', // Drivmedel bil
+  expense_telecom: '6200', // Telefon och internet
   expense_bank_fees: '6570', // Bankavgifter
   expense_card_fees: '6570', // Kortavgifter
   expense_currency_exchange: '7960', // Valutakursförluster
@@ -273,6 +277,10 @@ export const CATEGORY_LABELS: Record<TransactionCategory, string> = {
   expense_marketing: 'Marknadsföring',
   expense_professional_services: 'Konsulttjänster',
   expense_education: 'Utbildning',
+  expense_representation: 'Representation',
+  expense_consumables: 'Material',
+  expense_vehicle: 'Bil & drivmedel',
+  expense_telecom: 'Telefon & internet',
   expense_bank_fees: 'Bankavgift',
   expense_card_fees: 'Kortavgift',
   expense_currency_exchange: 'Valutaväxling',

extensions/general/user-description-match/index.ts

@@ -0,0 +1,142 @@
+import type { Extension, ExtensionContext } from '@/lib/extensions/types'
+import type { EventPayload } from '@/lib/events/types'
+
+// ============================================================
+// Settings
+// ============================================================
+
+export interface UserDescriptionMatchSettings {
+  batchApplyEnabled: boolean
+  minConfidenceThreshold: number
+}
+
+const DEFAULT_SETTINGS: UserDescriptionMatchSettings = {
+  batchApplyEnabled: true,
+  minConfidenceThreshold: 0.55,
+}
+
+export async function getSettings(userId: string): Promise<UserDescriptionMatchSettings> {
+  const { createClient } = await import('@/lib/supabase/server')
+  const supabase = await createClient()
+
+  const { data } = await supabase
+    .from('extension_data')
+    .select('value')
+    .eq('user_id', userId)
+    .eq('extension_id', 'user-description-match')
+    .eq('key', 'settings')
+    .single()
+
+  if (!data?.value) return { ...DEFAULT_SETTINGS }
+  return { ...DEFAULT_SETTINGS, ...(data.value as Partial<UserDescriptionMatchSettings>) }
+}
+
+export async function saveSettings(
+  userId: string,
+  partial: Partial<UserDescriptionMatchSettings>
+): Promise<UserDescriptionMatchSettings> {
+  const current = await getSettings(userId)
+  const merged = { ...current, ...partial }
+
+  const { createClient } = await import('@/lib/supabase/server')
+  const supabase = await createClient()
+
+  await supabase
+    .from('extension_data')
+    .upsert(
+      {
+        user_id: userId,
+        extension_id: 'user-description-match',
+        key: 'settings',
+        value: merged,
+      },
+      { onConflict: 'user_id,extension_id,key' }
+    )
+
+  return merged
+}
+
+// ============================================================
+// Event Handler
+// ============================================================
+
+async function handleTransactionCategorized(
+  payload: EventPayload<'transaction.categorized'>,
+  ctx?: ExtensionContext
+): Promise<void> {
+  const { transaction, userId } = payload
+  const log = ctx?.log ?? console
+
+  if (!transaction.merchant_name) return
+
+  const settings = ctx
+    ? { ...(DEFAULT_SETTINGS), ...(await ctx.settings.get<Partial<UserDescriptionMatchSettings>>() || {}) }
+    : await getSettings(userId)
+
+  if (!settings.batchApplyEnabled) return
+
+  try {
+    const supabase = ctx?.supabase ?? await (await import('@/lib/supabase/server')).createClient()
+
+    // Check if the rule that fired was a user-described rule
+    const { data: rule } = await supabase
+      .from('mapping_rules')
+      .select('id, user_description, merchant_pattern')
+      .eq('user_id', userId)
+      .eq('source', 'user_description')
+      .ilike('merchant_pattern', transaction.merchant_name.replace(/[.*+?^${}()|[\]\\]/g, '\\$&'))
+      .limit(1)
+      .single()
+
+    if (!rule) return
+
+    // Count uncategorized siblings
+    const { count } = await supabase
+      .from('transactions')
+      .select('id', { count: 'exact', head: true })
+      .eq('user_id', userId)
+      .eq('merchant_name', transaction.merchant_name)
+      .is('journal_entry_id', null)
+
+    if (!count || count === 0) return
+
+    // Store batch hint for the UI
+    await supabase.from('extension_data').upsert(
+      {
+        user_id: userId,
+        extension_id: 'user-description-match',
+        key: `batch_hint:${transaction.merchant_name}`,
+        value: {
+          merchant_name: transaction.merchant_name,
+          uncategorized_count: count,
+          user_description: rule.user_description,
+        },
+      },
+      { onConflict: 'user_id,extension_id,key' }
+    )
+
+    log.info(`[user-description-match] Batch hint stored: ${count} uncategorized for ${transaction.merchant_name}`)
+  } catch (error) {
+    log.error('[user-description-match] handleTransactionCategorized failed:', error)
+  }
+}
+
+// ============================================================
+// Extension Object
+// ============================================================
+
+export const userDescriptionMatchExtension: Extension = {
+  id: 'user-description-match',
+  name: 'Beskrivningsmatchning',
+  version: '1.0.0',
+  eventHandlers: [
+    { eventType: 'transaction.categorized', handler: handleTransactionCategorized },
+  ],
+  settingsPanel: {
+    label: 'Beskrivningsmatchning',
+    path: '/settings/extensions/user-description-match',
+  },
+  async onInstall(ctx) {
+    await ctx.settings.set('settings', DEFAULT_SETTINGS)
+  },
+}

lib/api/schemas.ts

@@ -72,6 +72,10 @@ export const TransactionCategorySchema = z.enum([
   'expense_marketing',
   'expense_professional_services',
   'expense_education',
+  'expense_representation',
+  'expense_consumables',
+  'expense_vehicle',
+  'expense_telecom',
   'expense_bank_fees',
   'expense_card_fees',
   'expense_currency_exchange',
@@ -306,6 +310,7 @@ export const CategorizeTransactionSchema = z.object({
   template_id: z.string().optional(),
   vat_treatment: VatTreatmentSchema.optional(),
   account_override: accountNumber.optional(),
+  user_description: z.string().max(500).optional(),
 })
 
 export const BookTransactionSchema = z.object({
@@ -323,6 +328,17 @@ export const MatchSupplierInvoiceSchema = z.object({
   supplier_invoice_id: uuid,
 })
 
+export const DescribeTransactionSchema = z.object({
+  description: z.string().min(3).max(500),
+})
+
+export const BatchDescribeSchema = z.object({
+  merchant_name: z.string().min(1),
+  template_id: z.string().min(1),
+  is_business: z.boolean(),
+  user_description: z.string().max(500).optional(),
+})
+
 // ============================================================
 // Settings schemas
 // ============================================================

lib/bookkeeping/__tests__/mapping-engine.test.ts

@@ -0,0 +1,141 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest'
+import { createMockSupabase, makeTransaction } from '@/tests/helpers'
+
+// Mock Supabase
+const { supabase: mockSupabase, mockResult } = createMockSupabase()
+vi.mock('@/lib/supabase/server', () => ({
+  createClient: vi.fn().mockResolvedValue(mockSupabase),
+}))
+
+// Mock booking-templates (needed by evaluateMappingRules)
+vi.mock('../booking-templates', () => ({
+  findMatchingTemplates: vi.fn().mockReturnValue([]),
+  buildMappingResultFromTemplate: vi.fn(),
+}))
+
+describe('mapping-engine', () => {
+  beforeEach(() => {
+    vi.clearAllMocks()
+  })
+
+  describe('saveUserMappingRule', () => {
+    it('saves auto-learned rule without user description', async () => {
+      const { saveUserMappingRule } = await import('../mapping-engine')
+
+      mockResult({ data: null, error: null })
+
+      await saveUserMappingRule('user-1', 'ICA Maxi', '5410', '1930', false)
+
+      // Verify insert was called via supabase.from().insert()
+      expect(mockSupabase.from).toHaveBeenCalledWith('mapping_rules')
+    })
+
+    it('saves user-described rule with priority 5 and confidence 0.98', async () => {
+      const { saveUserMappingRule } = await import('../mapping-engine')
+
+      mockResult({ data: null, error: null })
+
+      await saveUserMappingRule(
+        'user-1',
+        'Restaurant XYZ',
+        '6071',
+        '1930',
+        false,
+        'business lunch with client',
+        'restaurant_dining'
+      )
+
+      // Verify from was called (first for delete, then for insert)
+      expect(mockSupabase.from).toHaveBeenCalledWith('mapping_rules')
+    })
+
+    it('does not throw on insert error (non-critical)', async () => {
+      const { saveUserMappingRule } = await import('../mapping-engine')
+
+      mockResult({ data: null, error: { message: 'DB error' } })
+
+      // Should not throw
+      await expect(
+        saveUserMappingRule('user-1', 'ICA Maxi', '5410', '1930', false)
+      ).resolves.toBeUndefined()
+    })
+
+    it('escapes special regex characters in merchant name', async () => {
+      const { saveUserMappingRule } = await import('../mapping-engine')
+
+      mockResult({ data: null, error: null })
+
+      // Merchant name with regex special chars
+      await saveUserMappingRule('user-1', 'Test (Pty) Ltd.', '5410', '1930', false)
+
+      expect(mockSupabase.from).toHaveBeenCalledWith('mapping_rules')
+    })
+  })
+
+  describe('evaluateMappingRules', () => {
+    it('returns default result when no rules match', async () => {
+      const { evaluateMappingRules } = await import('../mapping-engine')
+
+      const tx = makeTransaction({ amount: -100, merchant_name: 'Unknown' })
+      mockResult({ data: [], error: null })
+
+      const result = await evaluateMappingRules('user-1', tx)
+
+      expect(result.debit_account).toBe('6991')
+      expect(result.credit_account).toBe('1930')
+      expect(result.confidence).toBe(0.1)
+      expect(result.requires_review).toBe(true)
+    })
+
+    it('matches merchant_pattern rule', async () => {
+      const { evaluateMappingRules } = await import('../mapping-engine')
+
+      const tx = makeTransaction({
+        amount: -299,
+        merchant_name: 'ICA Maxi',
+        description: 'ICA MAXI STOCKHOLM',
+      })
+
+      mockResult({
+        data: [
+          {
+            id: 'rule-1',
+            user_id: 'user-1',
+            rule_name: 'Learned: ICA Maxi',
+            rule_type: 'merchant_name',
+            priority: 10,
+            mcc_codes: null,
+            merchant_pattern: 'ICA Maxi',
+            description_pattern: null,
+            amount_min: null,
+            amount_max: null,
+            debit_account: '5410',
+            credit_account: '1930',
+            vat_treatment: null,
+            vat_debit_account: null,
+            vat_credit_account: null,
+            risk_level: 'NONE',
+            default_private: false,
+            requires_review: false,
+            confidence_score: 0.95,
+            capitalization_threshold: null,
+            capitalized_debit_account: null,
+            is_active: true,
+            source: 'auto',
+            user_description: null,
+            template_id: null,
+            created_at: '2024-01-01',
+            updated_at: '2024-01-01',
+          },
+        ],
+        error: null,
+      })
+
+      const result = await evaluateMappingRules('user-1', tx)
+
+      expect(result.debit_account).toBe('5410')
+      expect(result.credit_account).toBe('1930')
+      expect(result.confidence).toBe(0.95)
+    })
+  })
+})

lib/bookkeeping/__tests__/template-embeddings.test.ts

@@ -149,6 +149,40 @@ describe('template-embeddings', () => {
       expect(text).toContain('utgift')
       expect(text).not.toContain('MCC')
     })
+
+    it('prepends user description when provided', async () => {
+      const { buildTransactionQueryText } = await import('../template-embeddings')
+
+      const tx = makeTransaction({
+        description: 'SWE REST 4521 STHLM',
+        merchant_name: 'Unknown',
+        amount: -450,
+      })
+
+      const text = buildTransactionQueryText(tx, 'business lunch with client')
+
+      // User description should appear first
+      expect(text.indexOf('business lunch with client')).toBe(0)
+      // Transaction data should still be present
+      expect(text).toContain('SWE REST 4521 STHLM')
+      expect(text).toContain('Unknown')
+      expect(text).toContain('utgift')
+    })
+
+    it('behaves identically when userDescription is undefined', async () => {
+      const { buildTransactionQueryText } = await import('../template-embeddings')
+
+      const tx = makeTransaction({
+        description: 'SPOTIFY PREMIUM',
+        merchant_name: 'Spotify',
+        amount: -109,
+      })
+
+      const withoutDesc = buildTransactionQueryText(tx)
+      const withUndefined = buildTransactionQueryText(tx, undefined)
+
+      expect(withoutDesc).toBe(withUndefined)
+    })
   })
 
   describe('getSchemaVersion', () => {

lib/bookkeeping/category-mapping.ts

@@ -71,6 +71,10 @@ export function getCategoryAccountMapping(
     expense_marketing: '5910', // Annonsering
     expense_professional_services: '6530', // Redovisningstjänster
     expense_education: educationAccount,
+    expense_representation: '6071', // Representation, avdragsgill
+    expense_consumables: '5460', // Förbrukningsvaror
+    expense_vehicle: '5611', // Drivmedel bil
+    expense_telecom: '6200', // Telefon och internet
     expense_bank_fees: '6570', // Bankavgifter
     expense_card_fees: '6570', // Kortavgifter
     expense_currency_exchange: '7960', // Valutakursförluster
@@ -224,6 +228,10 @@ export function buildMappingResultFromCategory(
     expense_marketing: 'Marknadsföring',
     expense_professional_services: 'Konsulttjänst',
     expense_education: 'Utbildning',
+    expense_representation: 'Representation',
+    expense_consumables: 'Förbrukningsvaror',
+    expense_vehicle: 'Bil & drivmedel',
+    expense_telecom: 'Telefon & internet',
     expense_bank_fees: 'Bankavgift',
     expense_card_fees: 'Kortavgift',
     expense_currency_exchange: 'Valutaväxling',
@@ -262,6 +270,10 @@ export function getExpenseAccountForCategory(category: TransactionCategory): str
     expense_marketing: '5910',
     expense_professional_services: '6530',
     expense_education: '6991',
+    expense_representation: '6071',
+    expense_consumables: '5460',
+    expense_vehicle: '5611',
+    expense_telecom: '6200',
     expense_bank_fees: '6570',
     expense_card_fees: '6570',
     expense_currency_exchange: '7960',
@@ -292,6 +304,10 @@ export function getDefaultAccountForCategory(
     expense_marketing: '5910',
     expense_professional_services: '6530',
     expense_education: entityType === 'aktiebolag' ? '7610' : '6991',
+    expense_representation: '6071',
+    expense_consumables: '5460',
+    expense_vehicle: '5611',
+    expense_telecom: '6200',
     expense_bank_fees: '6570',
     expense_card_fees: '6570',
     expense_currency_exchange: '7960',

lib/bookkeeping/client-account-names.ts

@@ -0,0 +1,70 @@
+/**
+ * Client-safe account name map for UI display.
+ * Covers the ~30 accounts used in transaction categorization.
+ * No server dependencies — safe for 'use client' components.
+ */
+
+const ACCOUNT_NAMES: Record<string, string> = {
+  // Assets (1xxx)
+  '1510': 'Kundfordringar',
+  '1930': 'Foretagskonto',
+
+  // Equity & Liabilities (2xxx)
+  '2013': 'Ovriga egna uttag',
+  '2440': 'Leverantorsskulder',
+  '2611': 'Utg. moms 25%',
+  '2621': 'Utg. moms 12%',
+  '2631': 'Utg. moms 6%',
+  '2614': 'Utg. moms omvand',
+  '2641': 'Ing. moms',
+  '2645': 'Beraknad ing. moms',
+  '2893': 'Skuld till agare',
+
+  // Revenue (3xxx)
+  '3001': 'Forsaljning 25%',
+  '3002': 'Forsaljning 12%',
+  '3003': 'Forsaljning 6%',
+  '3305': 'Exportforsaljning',
+  '3308': 'EU-tjanster',
+  '3900': 'Ovriga rorelseintakter',
+
+  // Cost of goods (4xxx)
+  '4010': 'Varuinkop',
+
+  // External expenses (5xxx)
+  '5010': 'Lokalhyra',
+  '5410': 'Forbrukningsinventarier',
+  '5420': 'Programvaror',
+  '5460': 'Forbrukningsvaror',
+  '5611': 'Drivmedel bil',
+  '5800': 'Resekostnader',
+  '5910': 'Annonsering',
+
+  // Other external expenses (6xxx)
+  '6071': 'Representation',
+  '6200': 'Telefon & internet',
+  '6530': 'Redovisningstjanster',
+  '6570': 'Bankavgifter',
+  '6991': 'Ovriga kostnader',
+
+  // Personnel (7xxx)
+  '7610': 'Utbildning',
+  '7960': 'Valutakursforluster',
+  '3960': 'Valutakursvinster',
+}
+
+/**
+ * Get the Swedish display name for an account number.
+ * Returns the number itself if no name is mapped.
+ */
+export function getAccountName(accountNumber: string): string {
+  return ACCOUNT_NAMES[accountNumber] || accountNumber
+}
+
+/**
+ * Format an account number with its name, e.g. "5010 Lokalhyra".
+ */
+export function formatAccountWithName(accountNumber: string): string {
+  const name = ACCOUNT_NAMES[accountNumber]
+  return name ? `${accountNumber} ${name}` : accountNumber
+}

lib/bookkeeping/mapping-engine.ts

@@ -227,35 +227,78 @@ function getDefaultResult(transaction: Transaction): MappingResult {
 }
 
 /**
- * Save a user-level mapping rule learned from categorization
+ * Save a user-level mapping rule learned from categorization.
+ *
+ * When userDescription is provided, the rule gets:
+ * - source: 'user_description' (instead of 'auto')
+ * - priority: 5 (beats auto-learned at 10)
+ * - confidence_score: 0.98
+ * - The original user text and template_id stored for UI display
+ *
+ * User-described rules for the same merchant replace prior user-described rules
+ * (latest description wins).
  */
 export async function saveUserMappingRule(
   userId: string,
   merchantName: string,
   debitAccount: string,
   creditAccount: string,
-  isPrivate: boolean
+  isPrivate: boolean,
+  userDescription?: string,
+  templateId?: string
 ): Promise<void> {
   const supabase = await createClient()
 
   // Escape special regex characters in merchant name
   const escapedMerchant = merchantName.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')
 
-  const { error } = await supabase.from('mapping_rules').insert({
-    user_id: userId,
-    rule_name: `Learned: ${merchantName}`,
-    rule_type: 'merchant_name',
-    priority: 10, // User overrides have highest priority
-    merchant_pattern: escapedMerchant,
-    debit_account: debitAccount,
-    credit_account: creditAccount,
-    risk_level: 'NONE',
-    default_private: isPrivate,
-    requires_review: false,
-    confidence_score: 0.95,
-  })
+  if (userDescription) {
+    // Delete existing user_description rule for this merchant (latest wins)
+    await supabase
+      .from('mapping_rules')
+      .delete()
+      .eq('user_id', userId)
+      .eq('merchant_pattern', escapedMerchant)
+      .eq('source', 'user_description')
 
-  if (error) {
-    // Silently fail — saving learned rules is non-critical
+    const { error } = await supabase.from('mapping_rules').insert({
+      user_id: userId,
+      rule_name: `Described: ${merchantName}`,
+      rule_type: 'merchant_name',
+      priority: 5,
+      merchant_pattern: escapedMerchant,
+      debit_account: debitAccount,
+      credit_account: creditAccount,
+      risk_level: 'NONE',
+      default_private: isPrivate,
+      requires_review: false,
+      confidence_score: 0.98,
+      source: 'user_description',
+      user_description: userDescription,
+      template_id: templateId || null,
+    })
+
+    if (error) {
+      // Silently fail — saving learned rules is non-critical
+    }
+  } else {
+    const { error } = await supabase.from('mapping_rules').insert({
+      user_id: userId,
+      rule_name: `Learned: ${merchantName}`,
+      rule_type: 'merchant_name',
+      priority: 10,
+      merchant_pattern: escapedMerchant,
+      debit_account: debitAccount,
+      credit_account: creditAccount,
+      risk_level: 'NONE',
+      default_private: isPrivate,
+      requires_review: false,
+      confidence_score: 0.95,
+      source: 'auto',
+    })
+
+    if (error) {
+      // Silently fail — saving learned rules is non-critical
+    }
   }
 }

lib/bookkeeping/template-embeddings.ts

@@ -82,10 +82,19 @@ export function buildEmbeddingText(template: BookingTemplate): string {
 
 /**
  * Build query text from a transaction for embedding search.
+ * When userDescription is provided, it is prepended so it dominates
+ * the semantic search (user intent > raw bank text).
  */
-export function buildTransactionQueryText(transaction: Transaction): string {
+export function buildTransactionQueryText(
+  transaction: Transaction,
+  userDescription?: string
+): string {
   const parts: string[] = []
 
+  if (userDescription) {
+    parts.push(userDescription)
+  }
+
   if (transaction.description) {
     parts.push(transaction.description)
   }
@@ -180,7 +189,8 @@ let stalenessWarned = false
 export async function findSimilarTemplates(
   transaction: Transaction,
   entityType?: EntityType,
-  matchCount: number = MATCH_COUNT
+  matchCount: number = MATCH_COUNT,
+  userDescription?: string
 ): Promise<TemplateMatch[]> {
   try {
     const { createServiceClient } = await import('@/lib/supabase/server')
@@ -204,7 +214,7 @@ export async function findSimilarTemplates(
     }
 
     // Embed the transaction query text
-    const queryText = buildTransactionQueryText(transaction)
+    const queryText = buildTransactionQueryText(transaction, userDescription)
     const queryVector = await embeddings.embedQuery(queryText)
 
     // Request extra results to account for post-filtering

lib/extensions/__tests__/sectors.test.ts

@@ -11,8 +11,8 @@ describe('sectors registry', () => {
     expect(SECTORS.length).toBe(6)
   })
 
-  it('should have 18 total extensions', () => {
-    expect(getAllExtensions().length).toBe(19)
+  it('should have 20 total extensions', () => {
+    expect(getAllExtensions().length).toBe(20)
   })
 
   it('should have unique slugs within each sector', () => {

lib/extensions/icon-resolver.tsx

@@ -24,6 +24,7 @@ import {
   BarChart3,
   Layers,
   Puzzle,
+  TextSearch,
   type LucideIcon,
 } from 'lucide-react'
 
@@ -53,6 +54,7 @@ const ICON_MAP: Record<string, LucideIcon> = {
   BarChart3,
   Layers,
   Puzzle,
+  TextSearch,
 }
 
 export function resolveIcon(name: string): LucideIcon {

lib/extensions/loader.ts

@@ -7,6 +7,7 @@ import { neBilagaExtension } from '@/extensions/ne-bilaga'
 import { aiChatExtension } from '@/extensions/general/ai-chat'
 import { invoiceInboxExtension } from '@/extensions/general/invoice-inbox'
 import { calendarExtension } from '@/extensions/general/calendar'
+import { userDescriptionMatchExtension } from '@/extensions/general/user-description-match'
 import type { Extension } from './types'
 
 // ── Enable Banking (PSD2) — opt-in extension ───────────────────────────
@@ -30,6 +31,7 @@ const FIRST_PARTY_EXTENSIONS: Extension[] = [
   aiChatExtension,
   invoiceInboxExtension,
   calendarExtension,
+  userDescriptionMatchExtension,
   // enableBankingExtension,  // Uncomment to activate PSD2 bank sync
 ]
 

lib/extensions/sectors.ts

@@ -94,6 +94,18 @@ export const SECTORS: Sector[] = [
         longDescription:
           'Se alla fakturadatum och deadlines i en interaktiv kalender med manads-, vecko- och dagsvy.',
       },
+      {
+        slug: 'user-description-match',
+        name: 'Beskrivningsmatchning',
+        sector: 'general',
+        category: 'operations',
+        icon: 'TextSearch',
+        dataPattern: 'core',
+        readsCoreTables: ['transactions', 'mapping_rules'],
+        description: 'Matcha transaktioner med egna beskrivningar',
+        longDescription:
+          'Beskriv vad en transaktion gäller med egna ord och få smarta bokföringsförslag. Systemet lär sig av dina beskrivningar och applicerar automatiskt på framtida transaktioner från samma leverantör.',
+      },
       {
         slug: 'enable-banking',
         name: 'Bankintegration (PSD2)',

lib/extensions/workspace-registry.tsx

@@ -16,6 +16,7 @@ const WORKSPACES: Record<WorkspaceKey, ComponentType<WorkspaceComponentProps>> =
   'general/invoice-inbox': dynamic(() => import('@/components/extensions/general/InvoiceInboxWorkspace')),
   'general/calendar': dynamic(() => import('@/components/extensions/general/CalendarWorkspace')),
   'general/enable-banking': dynamic(() => import('@/components/extensions/general/EnableBankingWorkspace')),
+  'general/user-description-match': dynamic(() => import('@/components/extensions/general/UserDescriptionMatchWorkspace')),
   // Restaurant
   'restaurant/food-cost': dynamic(() => import('@/components/extensions/restaurant/FoodCostWorkspace')),
   'restaurant/earnings-per-liter': dynamic(() => import('@/components/extensions/restaurant/EarningsPerLiterWorkspace')),

lib/reports/__tests__/sie-export.test.ts

@@ -91,7 +91,7 @@ describe('generateSIEExport', () => {
 
     const output = await generateSIEExport('user-1', {
       ...baseOptions,
-      org_number: undefined,
+      org_number: null,
     })
 
     expect(output).not.toContain('#ORGNR')

lib/transactions/category-suggestions.ts

@@ -10,6 +10,7 @@ export interface SuggestedCategory {
   account: string | null
   confidence: number
   source: 'mapping_rule' | 'pattern' | 'history' | 'ai'
+  match_reason?: string
 }
 
 const CATEGORY_LABELS: Record<string, string> = {
@@ -23,6 +24,10 @@ const CATEGORY_LABELS: Record<string, string> = {
   expense_marketing: 'Marknadsföring',
   expense_professional_services: 'Konsulter',
   expense_education: 'Utbildning',
+  expense_representation: 'Representation',
+  expense_consumables: 'Material',
+  expense_vehicle: 'Bil & drivmedel',
+  expense_telecom: 'Telefon & internet',
   expense_bank_fees: 'Bankavgift',
   expense_card_fees: 'Kortavgift',
   expense_currency_exchange: 'Valutaväxling',
@@ -72,13 +77,17 @@ export function getSuggestedCategories(
       const category = accountToCategory(rule.debit_account, transaction.amount)
       if (category && !seen.has(category)) {
         seen.add(category)
-        suggestions.push({
+        const suggestion: SuggestedCategory = {
           category: category as TransactionCategory,
           label: CATEGORY_LABELS[category] || category,
           account: rule.debit_account,
           confidence: rule.confidence_score || 0.8,
           source: 'mapping_rule',
-        })
+        }
+        if (rule.source === 'user_description' && rule.user_description) {
+          suggestion.match_reason = `Matchad på din beskrivning: ${rule.user_description}`
+        }
+        suggestions.push(suggestion)
       }
     }
   }
@@ -140,9 +149,14 @@ function accountToCategory(account: string, amount: number): string | null {
   const expenseMap: Record<string, string> = {
     '5410': 'expense_equipment',
     '5420': 'expense_software',
+    '5460': 'expense_consumables',
+    '5611': 'expense_vehicle',
     '5800': 'expense_travel',
     '5010': 'expense_office',
     '5910': 'expense_marketing',
+    '6071': 'expense_representation',
+    '6072': 'expense_representation',
+    '6200': 'expense_telecom',
     '6530': 'expense_professional_services',
     '6570': 'expense_bank_fees',
     '6991': 'expense_other',
@@ -151,19 +165,40 @@ function accountToCategory(account: string, amount: number): string | null {
   return expenseMap[account] || null
 }
 
+/**
+ * Source priority for sorting — higher-quality sources rank first.
+ * AI and mapping rules always beat history-based guesses.
+ */
+const SOURCE_PRIORITY: Record<SuggestedCategory['source'], number> = {
+  mapping_rule: 3,
+  ai: 2,
+  pattern: 1,
+  history: 0,
+}
+
 /**
  * Merge AI-generated suggestions into existing suggestion list.
+ * AI suggestions take priority over history-based ones.
  * Deduplicates by category, preserving the higher-confidence entry.
+ * When transactionAmount is provided, filters out wrong-direction suggestions.
  */
 export function mergeAiSuggestions(
   existing: SuggestedCategory[],
-  aiSuggestions: { category: string; basAccount: string; confidence: number; reasoning: string }[]
+  aiSuggestions: { category: string; basAccount: string; confidence: number; reasoning: string }[],
+  transactionAmount?: number
 ): SuggestedCategory[] {
   const seen = new Set<string>(existing.map((s) => s.category))
   const merged = [...existing]
 
   for (const ai of aiSuggestions) {
     if (seen.has(ai.category)) continue
+
+    // Skip suggestions that don't match transaction direction
+    if (transactionAmount !== undefined) {
+      if (transactionAmount > 0 && ai.category.startsWith('expense_')) continue
+      if (transactionAmount < 0 && ai.category.startsWith('income_')) continue
+    }
+
     seen.add(ai.category)
 
     merged.push({
@@ -175,8 +210,13 @@ export function mergeAiSuggestions(
     })
   }
 
+  // Sort by source priority first, then by confidence within the same tier
   return merged
-    .sort((a, b) => b.confidence - a.confidence)
+    .sort((a, b) => {
+      const priorityDiff = SOURCE_PRIORITY[b.source] - SOURCE_PRIORITY[a.source]
+      if (priorityDiff !== 0) return priorityDiff
+      return b.confidence - a.confidence
+    })
     .slice(0, 5)
 }
 

supabase/migrations/20240101000041_user_description_matching.sql

@@ -0,0 +1,23 @@
+-- Migration: user_description_matching
+-- Adds source tracking, user description text, and template_id to mapping_rules
+-- to support user-description-based transaction matching.
+--
+-- Safe migration: all new columns have defaults or are nullable,
+-- so existing rows remain valid.
+
+-- 1. Add source column to track rule origin
+ALTER TABLE public.mapping_rules
+  ADD COLUMN IF NOT EXISTS source TEXT NOT NULL DEFAULT 'auto'
+  CHECK (source IN ('auto', 'user_description', 'system'));
+
+-- 2. Add user_description column to store the user's plain-language text
+ALTER TABLE public.mapping_rules
+  ADD COLUMN IF NOT EXISTS user_description TEXT;
+
+-- 3. Add template_id column to store the confirmed booking template
+ALTER TABLE public.mapping_rules
+  ADD COLUMN IF NOT EXISTS template_id TEXT;
+
+-- 4. Index for efficient upsert-on-merchant lookup by source
+CREATE INDEX IF NOT EXISTS idx_mapping_rules_user_merchant_source
+  ON public.mapping_rules (user_id, merchant_pattern, source);

tsconfig.json

@@ -20,7 +20,8 @@
     ],
     "paths": {
       "@/*": ["./*"]
-    }
+    },
+    "types": ["vitest/globals"]
   },
   "include": [
     "next-env.d.ts",

types/index.ts

@@ -13,6 +13,10 @@ export type TransactionCategory =
   | 'expense_marketing'
   | 'expense_professional_services'
   | 'expense_education'
+  | 'expense_representation'
+  | 'expense_consumables'
+  | 'expense_vehicle'
+  | 'expense_telecom'
   | 'expense_bank_fees'
   | 'expense_card_fees'
   | 'expense_currency_exchange'
@@ -899,6 +903,10 @@ export interface MappingRule {
   // Capitalization
   capitalization_threshold: number | null
   capitalized_debit_account: string | null
+  // Source tracking
+  source: 'auto' | 'user_description' | 'system'
+  user_description: string | null
+  template_id: string | null
   // Meta
   is_active: boolean
   created_at: string