feat: classification review UI with bulk-accept guardrails

client/src/App.tsx

@@ -19,6 +19,7 @@ import Accounts from "@/pages/Accounts";
 import Reports from "@/pages/Reports";
 import Integrations from "@/pages/Integrations";
 import Allocations from "@/pages/Allocations";
+import Classification from "@/pages/Classification";
 
 // Lazy-load the Orbital Console (57KB + physics sim + canvas rendering)
 const OrbitalConsole = lazy(() => import("@/pages/OrbitalConsole"));
@@ -59,6 +60,7 @@ function Router() {
             <Route path="/integrations" component={Integrations} />
             <Route path="/properties/:id" component={PropertyDetail} />
             <Route path="/allocations" component={Allocations} />
+            <Route path="/classification" component={Classification} />
             <Route path="/connections" component={Connections} />
             <Route path="/admin" component={Admin} />
             <Route path="/orbital">

client/src/components/layout/Sidebar.tsx

@@ -4,7 +4,7 @@ import {
   Settings, Plug, Building2, Shield,
   ChevronDown, ChevronRight, ChevronsUpDown,
   Menu, X, Activity, LayoutDashboard,
-  ArrowLeftRight, Wallet, BarChart3, Cable, Orbit, GitBranch
+  ArrowLeftRight, Wallet, BarChart3, Cable, Orbit, GitBranch, Tags
 } from "lucide-react";
 import { useState, useMemo } from "react";
 import { useRole, type UserRole } from "@/contexts/RoleContext";
@@ -26,6 +26,7 @@ const NAV_ITEMS: NavItem[] = [
   { href: "/accounts", label: "Accounts", icon: Wallet, roles: ["cfo", "accountant", "bookkeeper"] },
   { href: "/orbital", label: "Orbital", icon: Orbit, roles: ["cfo", "accountant", "bookkeeper", "user"], badge: "NEW" },
   { href: "/allocations", label: "Allocations", icon: GitBranch, roles: ["cfo", "accountant"] },
+  { href: "/classification", label: "Classification", icon: Tags, roles: ["cfo", "accountant", "bookkeeper"] },
   { href: "/reports", label: "Reports", icon: BarChart3, roles: ["cfo", "accountant"] },
   { href: "/integrations", label: "Integrations", icon: Cable, roles: ["cfo", "accountant"] },
   { href: "/connections", label: "Connections", icon: Plug, roles: ["cfo", "accountant"] },

client/src/hooks/use-classification.ts

@@ -0,0 +1,159 @@
+import { useQuery, useMutation, useQueryClient } from '@tanstack/react-query';
+import { apiRequest } from '@/lib/queryClient';
+import { useTenantId } from '@/contexts/TenantContext';
+
+// Matches database/system.schema.ts chartOfAccounts
+export interface ChartOfAccount {
+  id: string;
+  tenantId: string | null; // null = global default
+  code: string;
+  name: string;
+  type: 'asset' | 'liability' | 'equity' | 'income' | 'expense';
+  subtype: string | null;
+  description: string | null;
+  scheduleELine: string | null;
+  taxDeductible: boolean;
+  parentCode: string | null;
+  isActive: boolean;
+}
+
+// Matches database/system.schema.ts transactions (classification columns)
+export interface UnclassifiedTransaction {
+  id: string;
+  tenantId: string;
+  accountId: string;
+  amount: string;
+  type: string;
+  category: string | null;
+  description: string;
+  date: string;
+  payee: string | null;
+  coaCode: string | null;
+  suggestedCoaCode: string | null;
+  classificationConfidence: string | null;
+  classifiedBy: string | null;
+  classifiedAt: string | null;
+  reconciled: boolean;
+  reconciledBy: string | null;
+  reconciledAt: string | null;
+}
+
+export interface ClassificationStats {
+  total: number | string;
+  classified: number | string;
+  reconciled: number | string;
+  suggested: number | string;
+  unclassified: number;
+  classifiedPct: number;
+}
+
+export interface ClassificationAuditEntry {
+  id: string;
+  transactionId: string;
+  tenantId: string;
+  previousCoaCode: string | null;
+  newCoaCode: string;
+  action: string; // 'suggest' | 're-suggest' | 'classify' | 'reclassify' | 'reconcile'
+  trustLevel: string;
+  actorId: string;
+  actorType: 'user' | 'agent' | 'system';
+  confidence: string | null;
+  reason: string | null;
+  createdAt: string;
+}
+
+// ── Queries ──
+
+export function useChartOfAccounts() {
+  const tenantId = useTenantId();
+  return useQuery<ChartOfAccount[]>({
+    queryKey: ['/api/coa', tenantId],
+    enabled: !!tenantId,
+  });
+}
+
+export function useClassificationStats() {
+  const tenantId = useTenantId();
+  return useQuery<ClassificationStats>({
+    queryKey: ['/api/classification/stats', tenantId],
+    enabled: !!tenantId,
+  });
+}
+
+export function useUnclassifiedTransactions(limit = 50) {
+  const tenantId = useTenantId();
+  return useQuery<UnclassifiedTransaction[]>({
+    queryKey: ['/api/classification/unclassified', tenantId, limit],
+    enabled: !!tenantId,
+  });
+}
+
+export function useClassificationAudit(transactionId: string | null) {
+  return useQuery<ClassificationAuditEntry[]>({
+    queryKey: ['/api/classification/audit', transactionId],
+    enabled: !!transactionId,
+  });
+}
+
+// ── Mutations ──
+
+function invalidateClassificationCache(qc: ReturnType<typeof useQueryClient>) {
+  qc.invalidateQueries({ queryKey: ['/api/classification/stats'] });
+  qc.invalidateQueries({ queryKey: ['/api/classification/unclassified'] });
+}
+
+/** L2 — set authoritative coa_code on a transaction */
+export function useClassifyTransaction() {
+  const qc = useQueryClient();
+  return useMutation({
+    mutationFn: (data: { transactionId: string; coaCode: string; reason?: string; confidence?: string }) =>
+      apiRequest('POST', '/api/classification/classify', data).then((r) => r.json()),
+    onSuccess: () => invalidateClassificationCache(qc),
+  });
+}
+
+/** L1 — write a suggestion (manual override of AI/keyword) */
+export function useSuggestTransaction() {
+  const qc = useQueryClient();
+  return useMutation({
+    mutationFn: (data: { transactionId: string; coaCode: string; reason?: string; confidence?: string }) =>
+      apiRequest('POST', '/api/classification/suggest', data).then((r) => r.json()),
+    onSuccess: () => invalidateClassificationCache(qc),
+  });
+}
+
+/** L3 — lock a classified transaction */
+export function useReconcileTransaction() {
+  const qc = useQueryClient();
+  return useMutation({
+    mutationFn: (data: { transactionId: string }) =>
+      apiRequest('POST', '/api/classification/reconcile', data).then((r) => r.json()),
+    onSuccess: () => invalidateClassificationCache(qc),
+  });
+}
+
+/** L1 — run keyword-match batch over unclassified queue */
+export function useBatchSuggest() {
+  const qc = useQueryClient();
+  return useMutation({
+    mutationFn: (limit: number = 100) =>
+      apiRequest('POST', `/api/classification/batch-suggest?limit=${limit}`).then((r) => r.json()),
+    onSuccess: () => invalidateClassificationCache(qc),
+  });
+}
+
+/** L1 — run GPT-4o-mini AI batch over unclassified queue */
+export function useAiSuggest() {
+  const qc = useQueryClient();
+  return useMutation({
+    mutationFn: (limit: number = 25) =>
+      apiRequest('POST', `/api/classification/ai-suggest?limit=${limit}`).then((r) => r.json()) as Promise<{
+        processed: number;
+        suggested: number;
+        aiCount: number;
+        keywordCount: number;
+        aiAvailable: boolean;
+      }>,
+    onSuccess: () => invalidateClassificationCache(qc),
+  });
+}