diff --git a/docs/disaster-recovery.md b/docs/disaster-recovery.md
new file mode 100644
index 00000000..79482458
--- /dev/null
+++ b/docs/disaster-recovery.md
@@ -0,0 +1,138 @@
+# Disaster Recovery Runbook
+
+This document describes the backup, restoration, and disaster recovery (DR) procedures for the application. It is the authoritative runbook for on-call engineers and must be kept in sync with the implementation in `config.ts` and the backup automation.
+
+## Objectives
+
+| Metric | Target | Notes |
+| --- | --- | --- |
+| **RTO** (Recovery Time Objective) | **< 1 hour** | Time from declared incident to restored service. |
+| **RPO** (Recovery Point Objective) | **< 1 hour** | Maximum acceptable data loss window. |
+| Backup frequency | Every 30 minutes (incremental), daily (full) | Ensures RPO < 1 hour. |
+| Backup retention | 35 days | Daily fulls retained 35 days; incrementals 7 days. |
+
+## Configuration
+
+All backup and DR behavior is driven by environment variables defined in `config.ts`. Do not hardcode values elsewhere.
+
+| Variable | Purpose | Example |
+| --- | --- | --- |
+| `BACKUP_ENABLED` | Master switch for automated backups. | `true` |
+| `BACKUP_SCHEDULE_CRON` | Cron expression for incremental backups. | `*/30 * * * *` |
+| `BACKUP_FULL_SCHEDULE_CRON` | Cron expression for full backups. | `0 2 * * *` |
+| `BACKUP_RETENTION_DAYS` | Retention window for full backups. | `35` |
+| `BACKUP_STORAGE_BUCKET` | Primary (regional) backup bucket. | `app-backups-primary` |
+| `BACKUP_REPLICA_BUCKET` | Geo-redundant replica bucket in the secondary region. | `app-backups-replica` |
+| `BACKUP_PRIMARY_REGION` | Primary region for backups. | `us-east-1` |
+| `BACKUP_REPLICA_REGION` | Secondary region for geo-redundancy. | `us-west-2` |
+| `BACKUP_ENCRYPTION_KEY_ID` | KMS key used to encrypt backups at rest. | `arn:aws:kms:...` |
+| `BACKUP_ALERT_WEBHOOK_URL` | Webhook (Slack/PagerDuty) for backup failure alerts. | `https://hooks...` |
+| `BACKUP_ALERT_EMAIL` | Email distribution list for backup alerts. | `oncall@example.com` |
+| `BACKUP_VERIFY_SCHEDULE_CRON` | Cron for automated restore verification. | `0 4 * * *` |
+| `DR_DRILL_SCHEDULE_CRON` | Cron for scheduling DR drills. | `0 9 1 * *` |
+
+> If any of these variables are missing or invalid, the application should fail fast at startup (validation lives in `config.ts`).
+
+## Automated Backups
+
+1. **Incremental backups** run every 30 minutes per `BACKUP_SCHEDULE_CRON`. They capture changed data since the last backup and are written to `BACKUP_STORAGE_BUCKET` in `BACKUP_PRIMARY_REGION`.
+2. **Full backups** run daily at 02:00 UTC per `BACKUP_FULL_SCHEDULE_CRON`. Fulls are retained for `BACKUP_RETENTION_DAYS`.
+3. All backups are **encrypted at rest** using `BACKUP_ENCRYPTION_KEY_ID` and encrypted in transit (TLS).
+4. Each backup writes a **manifest** (checksum, timestamp, size, schema version) alongside the data. Restoration refuses to proceed if the manifest checksum does not match.
+5. Backups are **immutable** for the retention window (object lock) to protect against accidental deletion or ransomware.
+
+### Geo-Redundancy
+
+- After a backup lands in `BACKUP_STORAGE_BUCKET` (`BACKUP_PRIMARY_REGION`), it is **replicated asynchronously** to `BACKUP_REPLICA_BUCKET` in `BACKUP_REPLICA_REGION`.
+- Replication is expected to complete within 15 minutes. Replication lag is monitored; if lag exceeds 30 minutes an alert fires.
+- The replica region is a **separate failure domain** (different region, separate credentials scope). Restoration can be performed entirely from the replica if the primary region is unavailable.
+- Replication status is recorded per object; the verification job (below) checks that the latest backup exists in both buckets.
+
+## Failure Alerting
+
+- Any backup job that fails, times out, or produces a manifest with a checksum mismatch triggers an alert to `BACKUP_ALERT_WEBHOOK_URL` and `BACKUP_ALERT_EMAIL`.
+- Alerts include: job type, timestamp, error, and a link to the job logs.
+- **Missing backup detection:** a watchdog checks that a backup landed within the last 60 minutes. If not, it fires a high-severity alert (this protects the RPO).
+- **Replication lag alert:** fires if replica lag exceeds 30 minutes.
+- **Verification failure alert:** fires if the automated restore verification (`BACKUP_VERIFY_SCHEDULE_CRON`) fails.
+- Alerts page the on-call engineer. Acknowledged alerts must be triaged within 15 minutes.
+
+## Restoration Procedure
+
+> **Goal: complete restoration in under 1 hour (RTO).** Follow the steps in order. Record timestamps at each step for the post-incident review.
+
+### 0. Declare and assess (target: 5 min)
+
+1. Declare an incident in the incident channel and assign an Incident Commander.
+2. Determine the scope: which data, which environment, and whether the primary region is available.
+3. Decide the source: **primary bucket** if healthy, otherwise the **replica bucket** (`BACKUP_REPLICA_BUCKET` in `BACKUP_REPLICA_REGION`).
+
+### 1. Identify the target backup (target: 5 min)
+
+1. List available backups and their manifests.
+2. Select the most recent backup whose manifest checksum validates. Prefer the latest backup that satisfies the RPO (< 1 hour old).
+3. Record the chosen backup ID and timestamp.
+
+### 2. Prepare the restore target (target: 10 min)
+
+1. Provision or identify the target database/storage for restoration.
+2. Confirm the KMS key (`BACKUP_ENCRYPTION_KEY_ID`) is accessible from the restore environment.
+3. Ensure the application is in maintenance mode / traffic is drained to avoid writes during restore.
+
+### 3. Restore data (target: 20 min)
+
+1. Download the selected backup (and any required incrementals) from the chosen bucket.
+2. Verify the manifest checksum **before** applying.
+3. Apply the full backup, then replay incrementals in timestamp order.
+4. Monitor restore logs for errors; abort and escalate on checksum or schema-version mismatch.
+
+### 4. Validate (target: 10 min)
+
+1. Run integrity checks (row counts, key table checksums, referential integrity).
+2. Run the smoke-test suite against the restored data.
+3. Confirm the restored data timestamp is within the RPO window.
+
+### 5. Cut over (target: 10 min)
+
+1. Point the application at the restored data store.
+2. Exit maintenance mode and re-enable traffic.
+3. Monitor error rates and latency for 15 minutes.
+4. Announce recovery and close the incident; schedule the post-incident review.
+
+### Tested Steps
+
+The restoration procedure above is exercised by the **automated restore verification** job (`BACKUP_VERIFY_SCHEDULE_CRON`), which restores the latest backup into an isolated environment, runs the integrity checks and smoke tests, and reports success/failure. A failure raises an alert. Manual drills (below) additionally validate the full cut-over path.
+
+## DR Drills
+
+DR drills are scheduled per `DR_DRILL_SCHEDULE_CRON` (monthly) and are mandatory. Each drill must be recorded with a report linked from the incident tracker.
+
+### Drill Checklist
+
+- [ ] Announce the drill window to stakeholders; confirm no conflicting changes are scheduled.
+- [ ] Simulate a failure scenario (e.g., primary region unavailable, corrupted primary backup).
+- [ ] Perform the full **Restoration Procedure** from the replica region.
+- [ ] Measure and record **RTO** (must be < 1 hour) and **RPO** (must be < 1 hour).
+- [ ] Verify alerts fired as expected (backup failure, replication lag, verification failure).
+- [ ] Confirm the restored environment passes integrity checks and smoke tests.
+- [ ] Tear down drill resources and confirm no impact to production.
+- [ ] File a drill report: timestamps, metrics, issues found, and action items.
+- [ ] Track action items to completion; update this runbook if procedures changed.
+
+### Team Training
+
+- All on-call engineers must complete a walkthrough of this runbook and participate in at least one drill before being added to the on-call rotation.
+- Training records are maintained by the team lead. Re-training is required whenever this runbook changes materially.
+
+## Roles and Responsibilities
+
+| Role | Responsibility |
+| --- | --- |
+| Incident Commander | Declares incident, coordinates restoration, owns RTO. |
+| Restore Operator | Executes restoration steps and records timestamps. |
+| Communications Lead | Updates stakeholders and status page. |
+| Backup Owner | Maintains backup automation, alerts, and this runbook. |
+
+## Post-Incident Review
+
+Within 5 business days of any restoration or failed drill, hold a post-incident review covering: timeline vs. RTO/RPO, root cause, alert effectiveness, and concrete action items with owners and due dates. Update this runbook and `config.ts` as needed.
\ No newline at end of file
diff --git a/instrumentation-client.ts b/instrumentation-client.ts
index 4566ad69..afcbfbdf 100644
--- a/instrumentation-client.ts
+++ b/instrumentation-client.ts
@@ -13,3 +13,178 @@ if (dsn) {
 }
 
 export const onRouterTransitionStart = Sentry.captureRouterTransitionStart;
+
+/**
+ * Analytics consent state.
+ * Analytics must never run unless the user has explicitly granted consent.
+ */
+const ANALYTICS_CONSENT_KEY = "analytics-consent";
+
+type AnalyticsConsent = "granted" | "denied" | "unknown";
+
+function readConsent(): AnalyticsConsent {
+  if (typeof window === "undefined") return "unknown";
+  try {
+    const value = window.localStorage.getItem(ANALYTICS_CONSENT_KEY);
+    if (value === "granted" || value === "denied") return value;
+    return "unknown";
+  } catch {
+    // localStorage may be unavailable (e.g. privacy mode); treat as no consent.
+    return "unknown";
+  }
+}
+
+function hasConsent(): boolean {
+  return readConsent() === "granted";
+}
+
+/**
+ * Minimal analytics client interface. The concrete provider is initialized
+ * lazily and only after consent is granted.
+ */
+interface AnalyticsClient {
+  init: (options: { dsn?: string; sampleRate?: number }) => void;
+  track: (event: string, properties?: Record<string, unknown>) => void;
+  flush: () => void;
+}
+
+let analyticsClient: AnalyticsClient | null = null;
+let analyticsInitialized = false;
+let flushHandlerAttached = false;
+
+/**
+ * Queue of events captured before the provider finished initializing.
+ * Kept small and bounded to avoid unbounded memory growth.
+ */
+const MAX_QUEUE_SIZE = 100;
+const eventQueue: Array<{ event: string; properties?: Record<string, unknown> }> = [];
+
+function enqueue(event: string, properties?: Record<string, unknown>): void {
+  if (eventQueue.length >= MAX_QUEUE_SIZE) {
+    eventQueue.shift();
+  }
+  eventQueue.push({ event, properties });
+}
+
+function drainQueue(client: AnalyticsClient): void {
+  while (eventQueue.length > 0) {
+    const item = eventQueue.shift();
+    if (item) {
+      try {
+        client.track(item.event, item.properties);
+      } catch {
+        // Never let analytics failures break the app.
+      }
+    }
+  }
+}
+
+/**
+ * Lazily load and initialize the analytics provider. This is intentionally
+ * non-blocking: it is scheduled on an idle callback (or a microtask fallback)
+ * so it never impacts initial page performance.
+ */
+function initAnalytics(): void {
+  if (typeof window === "undefined") return;
+  if (analyticsInitialized) return;
+  if (!hasConsent()) return;
+
+  analyticsInitialized = true;
+
+  const start = () => {
+    // Re-check consent in case it was revoked before the idle callback ran.
+    if (!hasConsent()) {
+      analyticsInitialized = false;
+      return;
+    }
+
+    import("./analytics-client")
+      .then((mod) => {
+        const client = mod.createAnalyticsClient();
+        analyticsClient = client;
+        client.init({
+          dsn: process.env.NEXT_PUBLIC_ANALYTICS_DSN,
+          sampleRate: 1.0,
+        });
+        drainQueue(client);
+      })
+      .catch(() => {
+        // Provider failed to load; reset so a later attempt can retry.
+        analyticsInitialized = false;
+      });
+  };
+
+  if (typeof window.requestIdleCallback === "function") {
+    window.requestIdleCallback(start, { timeout: 2000 });
+  } else {
+    window.setTimeout(start, 0);
+  }
+}
+
+/**
+ * Track a user action. No-op unless consent has been granted.
+ * Safe to call from anywhere in the client bundle.
+ */
+export function trackEvent(
+  event: string,
+  properties?: Record<string, unknown>,
+): void {
+  if (typeof window === "undefined") return;
+  if (!hasConsent()) return;
+
+  if (analyticsClient) {
+    try {
+      analyticsClient.track(event, properties);
+    } catch {
+      // Swallow analytics errors.
+    }
+    return;
+  }
+
+  enqueue(event, properties);
+  // Ensure the provider is (or will be) initialized.
+  initAnalytics();
+}
+
+/**
+ * Flush any queued events. Intended to be called on page hide / unload so
+ * events are not lost. Uses `visibilitychange` + `pagehide` for reliability
+ * across browsers (including bfcache).
+ */
+export function flushAnalytics(): void {
+  if (typeof window === "undefined") return;
+  if (!hasConsent()) return;
+
+  if (analyticsClient) {
+    try {
+      analyticsClient.flush();
+    } catch {
+      // Swallow analytics errors.
+    }
+  }
+}
+
+function attachFlushHandler(): void {
+  if (typeof window === "undefined") return;
+  if (flushHandlerAttached) return;
+  flushHandlerAttached = true;
+
+  const onPageHide = () => {
+    flushAnalytics();
+  };
+
+  const onVisibilityChange = () => {
+    if (document.visibilityState === "hidden") {
+      flushAnalytics();
+    }
+  };
+
+  window.addEventListener("pagehide", onPageHide);
+  window.addEventListener("visibilitychange", onVisibilityChange);
+}
+
+// Initialize analytics on the client, gated by consent and non-blocking.
+if (typeof window !== "undefined") {
+  attachFlushHandler();
+  initAnalytics();
+}
\ No newline at end of file
diff --git a/instrumentation.ts b/instrumentation.ts
index 88d64d6d..e14d89dd 100644
--- a/instrumentation.ts
+++ b/instrumentation.ts
@@ -1,22 +1,76 @@
 import * as Sentry from "@sentry/nextjs";
+import { initAnalytics } from "./lib/analytics/server";
+import { registerBackupScheduler } from "./lib/backup/scheduler";
 
 export async function register() {
   const dsn = process.env.NEXT_PUBLIC_SENTRY_DSN;
-  if (!dsn) return;
+  if (dsn) {
+    if (process.env.NEXT_RUNTIME === "nodejs") {
+      Sentry.init({
+        dsn,
+        tracesSampleRate: 0.1,
+        debug: false,
+      });
+    }
 
-  if (process.env.NEXT_RUNTIME === "nodejs") {
-    Sentry.init({
-      dsn,
-      tracesSampleRate: 0.1,
-      debug: false,
-    });
+    if (process.env.NEXT_RUNTIME === "edge") {
+      Sentry.init({
+        dsn,
+        tracesSampleRate: 0.1,
+        debug: false,
+      });
+    }
+  }
+
+  const analyticsEnabled =
+    process.env.ANALYTICS_ENABLED === "true" ||
+    process.env.NEXT_PUBLIC_ANALYTICS_ENABLED === "true";
+
+  if (
+    analyticsEnabled &&
+    (process.env.NEXT_RUNTIME === "nodejs" ||
+      process.env.NEXT_RUNTIME === "edge")
+  ) {
+    const endpoint = process.env.ANALYTICS_ENDPOINT;
+    const samplingRate = Number.parseFloat(
+      process.env.ANALYTICS_SAMPLING_RATE ?? "1",
+    );
+
+    try {
+      await initAnalytics({
+        endpoint,
+        samplingRate: Number.isFinite(samplingRate) ? samplingRate : 1,
+        runtime: process.env.NEXT_RUNTIME,
+      });
+    } catch (error) {
+      console.error("[instrumentation] Failed to initialize analytics", error);
+    }
   }
 
-  if (process.env.NEXT_RUNTIME === "edge") {
-    Sentry.init({
-      dsn,
-      tracesSampleRate: 0.1,
-      debug: false,
-    });
+  if (process.env.NEXT_RUNTIME === "nodejs") {
+    try {
+      await registerBackupScheduler({
+        onFailure: async (error: unknown, context: { runId?: string }) => {
+          console.error("[instrumentation] Backup run failed", error, context);
+
+          if (dsn) {
+            Sentry.captureException(error, {
+              tags: { component: "backup-scheduler" },
+              extra: { runId: context?.runId },
+            });
+          }
+
+          const { notifyBackupFailure } = await import(
+            "./lib/notifications/backup"
+          );
+          await notifyBackupFailure({ error, context });
+        },
+      });
+    } catch (error) {
+      console.error(
+        "[instrumentation] Failed to register backup scheduler",
+        error,
+      );
+    }
   }
-}
+}
\ No newline at end of file
diff --git a/src/app/analytics/page.tsx b/src/app/analytics/page.tsx
index baaac115..0ad515a2 100644
--- a/src/app/analytics/page.tsx
+++ b/src/app/analytics/page.tsx
@@ -8,6 +8,18 @@ import { getFreighterPublicKey } from "@/lib/freighter";
 import { generateCsv, type CsvRow } from "@/lib/csvExport";
 import type { Invoice } from "@stellar-split/sdk";
 import ChartBuilder, { type ChartBuilderDataPoint } from "@/components/analytics/ChartBuilder";
+import {
+  getEventCounts,
+  getFunnel,
+  getActiveWalletCount,
+  type AnalyticsEventName,
+} from "@/lib/analytics";
+import {
+  computeAgingBuckets,
+  computeAgingTrend,
+  type AgingBucket,
+  type AgingTrendPoint,
+} from "@/lib/invoiceAging";
 
 const STROOPS = 10_000_000;
 
@@ -37,6 +49,16 @@ const DynamicFundingTimeHistogram = dynamic(
   { ssr: false }
 );
 
+const DynamicAgingBucketChart = dynamic(
+  () => import("@/components/analytics/AgingBucketChart"),
+  { ssr: false }
+);
+
+const DynamicAgingTrendChart = dynamic(
+  () => import("@/components/analytics/AgingTrendChart"),
+  { ssr: false }
+);
+
 function KpiCard({
   label,
   value,
@@ -119,6 +141,11 @@ export default function AnalyticsPage() {
   const [error, setError] = useState<string | null>(null);
   const [dateFrom, setDateFrom] = useState("");
   const [dateTo, setDateTo] = useState("");
+  const [appMetrics, setAppMetrics] = useState<{
+    eventCounts: Record<AnalyticsEventName, number>;
+    funnel: { label: string; count: number }[];
+    activeWallets: number;
+  } | null>(null);
 
   useEffect(() => {
     getFreighterPublicKey()
@@ -126,6 +153,17 @@ export default function AnalyticsPage() {
       .catch(() => setError("Connect your Freighter wallet to view analytics."));
   }, []);
 
+  useEffect(() => {
+    try {
+      const eventCounts = getEventCounts();
+      const funnel = getFunnel();
+      const activeWallets = getActiveWalletCount();
+      setAppMetrics({ eventCounts, funnel, activeWallets });
+    } catch {
+      setAppMetrics(null);
+    }
+  }, []);
+
   useEffect(() => {
     if (!publicKey) return;
     const fetchInvoices = async () => {
@@ -305,6 +343,13 @@ export default function AnalyticsPage() {
     };
   }, [filtered]);
 
+  const aging = useMemo(() => {
+    const now = Math.floor(Date.now() / 1000);
+    const buckets: AgingBucket[] = computeAgingBuckets(filtered, now);
+    const trend: AgingTrendPoint[] = computeAgingTrend(filtered, now);
+    return { buckets, trend };
+  }, [filtered]);
+
   const csvRows = useMemo<CsvRow[]>(() => {
     return filtered.map((inv) => ({
       id: inv.id,
@@ -464,6 +509,99 @@ export default function AnalyticsPage() {
           <ChartBuilder data={stats.chartBuilderData} />
         </div>
 
+        <div className="bg-gray-900 rounded-xl border border-gray-800 p-5 mb-8">
+          <h2 className="text-sm font-semibold text-gray-300 mb-4 uppercase tracking-wider">
+            Application Metrics
+          </h2>
+          {!appMetrics ? (
+            <p className="text-gray-500 text-sm text-center py-8">
+              No application metrics available.
+            </p>
+          ) : (
+            <div className="grid grid-cols-1 lg:grid-cols-2 gap-6">
+              <div>
+                <p className="text-xs text-gray-500 uppercase tracking-wider mb-2">
+                  Event Counts
+                </p>
+                <ul className="space-y-1.5 text-sm">
+                  {Object.entries(appMetrics.eventCounts).map(([name, count]) => (
+                    <li
+                      key={name}
+                      className="flex items-center justify-between border-b border-gray-800/60 py-1.5"
+                    >
+                      <span className="text-gray-400">{name}</span>
+                      <span className="text-indigo-300 font-medium">{count}</span>
+                    </li>
+                  ))}
+                </ul>
+                <p className="text-xs text-gray-500 mt-4">
+                  Active wallets:{" "}
+                  <span className="text-indigo-300 font-medium">
+                    {appMetrics.activeWallets}
+                  </span>
+                </p>
+              </div>
+              <div>
+                <p className="text-xs text-gray-500 uppercase tracking-wider mb-2">
+                  Funnel (create → pay → release)
+                </p>
+                <ul className="space-y-2 text-sm">
+                  {appMetrics.funnel.map((step) => (
+                    <li key={step.label}>
+                      <div className="flex items-center justify-between mb-1">
+                        <span className="text-gray-400">{step.label}</span>
+                        <span className="text-indigo-300 font-medium">
+                          {step.count}
+                        </span>
+                      </div>
+                      <div className="h-2 bg-gray-800 rounded-full overflow-hidden">
+                        <div
+                          className="h-full bg-indigo-500"
+                          style={{
+                            width: `${
+                              appMetrics.funnel[0]?.count
+                                ? Math.min(
+                                    100,
+                                    (step.count / appMetrics.funnel[0].count) *
+                                      100
+                                  )
+                                : 0
+                            }%`,
+                          }}
+                        />
+                      </div>
+                    </li>
+                  ))}
+                </ul>
+              </div>
+            </div>
+          )}
+        </div>
+
+        <div className="bg-gray-900 rounded-xl border border-gray-800 p-5 mb-8">
+          <h2 className="text-sm font-semibold text-gray-300 mb-4 uppercase tracking-wider">
+            Invoice Aging
+          </h2>
+          <div className="grid grid-cols-1 lg:grid-cols-2 gap-6">
+            <div>
+              <p className="text-xs text-gray-500 uppercase tracking-wider mb-2">
+                Aging Buckets
+              </p>
+              <Suspense fallback={<ChartFallback />}>
+                <DynamicAgingBucketChart data={aging.buckets} />
+              </Suspense>
+            </div>
+            <div>
+              <p className="text-xs text-gray-500 uppercase tracking-wider mb-2">
+                Aging Trend
+              </p>
+              <Suspense fallback={<ChartFallback />}>
+                <DynamicAgingTrendChart data={aging.trend} />
+              </Suspense>
+            </div>
+          </div>
+        </div>
+
         <div className="bg-gray-900 rounded-xl border border-gray-800 p-5 mb-8">
           <h2 className="text-sm font-semibold text-gray-300 mb-4 uppercase tracking-wider">
             Top Invoices by Volume
diff --git a/src/components/AnalyticsPanel.tsx b/src/components/AnalyticsPanel.tsx
index 0c9b4c94..d7302bc4 100644
--- a/src/components/AnalyticsPanel.tsx
+++ b/src/components/AnalyticsPanel.tsx
@@ -6,11 +6,56 @@ import { useI18n } from "@/components/I18nProvider";
 import type { Invoice } from "@stellar-split/sdk";
 import { BarChart, Bar, XAxis, YAxis, CartesianGrid, Tooltip, Legend, ResponsiveContainer } from "recharts";
 import { Skeleton } from "@/components/Skeleton";
+import { getAnalyticsSummary, type AnalyticsSummary } from "@/lib/analytics";
+import { calculateAgingBuckets, type AgingBucket } from "@/lib/invoiceAging";
 
 interface Props {
   invoices: Invoice[];
 }
 
+interface AppMetrics {
+  eventTotals: { name: string; count: number }[];
+  funnel: { step: string; count: number; conversion: number }[];
+  activeUsers: number;
+}
+
+const FUNNEL_STEPS = ["invoice_created", "invoice_funded", "invoice_released"] as const;
+
+function buildAppMetrics(summary: AnalyticsSummary): AppMetrics {
+  const totals = new Map<string, number>();
+  for (const event of summary.events) {
+    totals.set(event.name, (totals.get(event.name) ?? 0) + 1);
+  }
+  const eventTotals = Array.from(totals.entries())
+    .map(([name, count]) => ({ name, count }))
+    .sort((a, b) => b.count - a.count);
+
+  const funnelTop = totals.get(FUNNEL_STEPS[0]) ?? 0;
+  const funnel = FUNNEL_STEPS.map((step) => {
+    const count = totals.get(step) ?? 0;
+    return {
+      step,
+      count,
+      conversion: funnelTop > 0 ? Math.round((count / funnelTop) * 100) : 0,
+    };
+  });
+
+  return { eventTotals, funnel, activeUsers: summary.activeUsers };
+}
+
+function trendIndicator(current: number, previous: number): { label: string; className: string } {
+  if (previous === 0) {
+    return current > 0
+      ? { label: "▲ new", className: "text-red-400" }
+      : { label: "—", className: "text-gray-500" };
+  }
+  const change = ((current - previous) / previous) * 100;
+  if (Math.abs(change) < 1) return { label: "— 0%", className: "text-gray-400" };
+  return change > 0
+    ? { label: `▲ ${change.toFixed(0)}%`, className: "text-red-400" }
+    : { label: `▼ ${Math.abs(change).toFixed(0)}%`, className: "text-green-400" };
+}
+
 type RangePreset = "7d" | "30d" | "3m" | "custom";
 
 interface RangeOption {
@@ -96,6 +141,30 @@ export default function AnalyticsPanel({ invoices }: Props) {
     .sort(([a], [b]) => a.localeCompare(b))
     .map(([week, count]) => ({ week, invoices: count }));
 
+  // Application metrics (event tracking + funnel + active users) for the range.
+  const appMetrics = useMemo(() => {
+    const summary = getAnalyticsSummary({ from, to });
+    return buildAppMetrics(summary);
+  }, [from, to]);
+
+  // Invoice aging buckets for the current scoped invoices, with a trend
+  // indicator comparing the current window against the preceding window.
+  const aging = useMemo(() => {
+    const current = calculateAgingBuckets(scopedInvoices, to);
+    const windowSeconds = Math.max(to - from, 0);
+    const prevFrom = from - windowSeconds;
+    const prevInvoices = invoices.filter(
+      (inv) => inv.deadline >= prevFrom && inv.deadline < from
+    );
+    const previous = calculateAgingBuckets(prevInvoices, from);
+    return { current, previous };
+  }, [scopedInvoices, invoices, from, to]);
+
+  const overdueTrend = trendIndicator(
+    aging.current.overdueTotal,
+    aging.previous.overdueTotal
+  );
+
   return (
     <div className="bg-gray-900 rounded-xl p-4 sm:p-5 mb-6">
       <button
@@ -203,6 +272,71 @@ export default function AnalyticsPanel({ invoices }: Props) {
             </div>
           </div>
 
+          {/* Invoice Aging Summary */}
+          <div className="bg-gray-800 rounded-lg p-4">
+            <div className="flex items-center justify-between mb-3">
+              <p className="text-sm text-gray-400">{t("dashboard.agingSummary")}</p>
+              <span
+                className={`text-xs font-medium ${overdueTrend.className}`}
+                aria-label="Overdue trend versus previous period"
+              >
+                {overdueTrend.label}
+              </span>
+            </div>
+            <div className="grid grid-cols-2 sm:grid-cols-4 gap-3">
+              {aging.current.buckets.map((bucket: AgingBucket) => (
+                <div key={bucket.key} className="bg-gray-900/60 rounded-lg p-3">
+                  <p className="text-xs text-gray-400 mb-1">{bucket.label}</p>
+                  <p className="text-sm font-semibold text-gray-200">
+                    {formatAmount(bucket.amount)}
+                  </p>
+                  <p className="text-xs text-gray-500">{bucket.count} invoices</p>
+                </div>
+              ))}
+            </div>
+          </div>
+
+          {/* Application Metrics */}
+          <div className="grid grid-cols-1 sm:grid-cols-3 gap-3">
+            <div className="bg-gray-800 rounded-lg p-4">
+              <p className="text-xs text-gray-400 mb-1">{t("dashboard.activeUsers")}</p>
+              <p className="text-lg font-semibold">{appMetrics.activeUsers}</p>
+            </div>
+            <div className="bg-gray-800 rounded-lg p-4 sm:col-span-2">
+              <p className="text-xs text-gray-400 mb-2">{t("dashboard.conversionFunnel")}</p>
+              <div className="flex flex-wrap items-center gap-2">
+                {appMetrics.funnel.map((step) => (
+                  <div
+                    key={step.step}
+                    className="flex-1 min-w-[90px] bg-gray-900/60 rounded-lg px-3 py-2"
+                  >
+                    <p className="text-xs text-gray-400 truncate">{step.step}</p>
+                    <p className="text-sm font-semibold text-gray-200">{step.count}</p>
+                    <p className="text-xs text-indigo-300">{step.conversion}%</p>
+                  </div>
+                ))}
+              </div>
+            </div>
+          </div>
+
+          {/* Event Totals */}
+          {appMetrics.eventTotals.length > 0 && (
+            <div className="bg-gray-800 rounded-lg p-4">
+              <p className="text-sm text-gray-400 mb-3">{t("dashboard.eventTotals")}</p>
+              <ul className="space-y-1">
+                {appMetrics.eventTotals.slice(0, 8).map((event) => (
+                  <li
+                    key={event.name}
+                    className="flex items-center justify-between text-xs text-gray-300"
+                  >
+                    <span className="truncate">{event.name}</span>
+                    <span className="font-semibold text-gray-200">{event.count}</span>
+                  </li>
+                ))}
+              </ul>
+            </div>
+          )}
+
           {/* Weekly Chart */}
           {chartData.length > 0 && (
             <div className="bg-gray-800 rounded-lg p-4 overflow-x-auto">
diff --git a/src/components/AuditLogTable.tsx b/src/components/AuditLogTable.tsx
index 00bf603d..d463b744 100644
--- a/src/components/AuditLogTable.tsx
+++ b/src/components/AuditLogTable.tsx
@@ -14,6 +14,10 @@ interface AuditLogEntry {
   action: string;
   actor: string;
   timestamp: number;
+  version?: number;
+  diffSummary?: string;
+  amendmentReason?: string;
+  amendmentComment?: string;
 }
 
 interface Props {
@@ -40,7 +44,21 @@ export default function AuditLogTable({ invoiceId, invoice }: Props) {
   const handleExportJSON = () => {
     if (!invoice) return;
     const nonPendingPayments = invoice.payments.filter((p) => !p.pending);
-    const archive = buildInvoiceArchive(invoice, entries, nonPendingPayments);
+    const versionHistory = entries
+      .filter((entry) => entry.version !== undefined)
+      .map((entry) => ({
+        version: entry.version,
+        action: entry.action,
+        actor: entry.actor,
+        timestamp: entry.timestamp,
+        diffSummary: entry.diffSummary,
+        amendmentReason: entry.amendmentReason,
+        amendmentComment: entry.amendmentComment,
+      }));
+    const archive = {
+      ...buildInvoiceArchive(invoice, entries, nonPendingPayments),
+      versionHistory,
+    };
     const filename = generateArchiveFilename(invoiceId);
     downloadInvoiceArchive(archive, filename);
   };
@@ -121,6 +139,8 @@ export default function AuditLogTable({ invoiceId, invoice }: Props) {
           <thead>
             <tr className="border-b border-gray-700">
               <th className="text-left px-4 py-2 font-semibold text-gray-300">Action</th>
+              <th className="text-left px-4 py-2 font-semibold text-gray-300">Version</th>
+              <th className="text-left px-4 py-2 font-semibold text-gray-300">Changes</th>
               <th className="text-left px-4 py-2 font-semibold text-gray-300">Actor</th>
               <th className="text-left px-4 py-2 font-semibold text-gray-300">Timestamp</th>
             </tr>
@@ -129,6 +149,27 @@ export default function AuditLogTable({ invoiceId, invoice }: Props) {
             {paginatedEntries.map((entry, idx) => (
               <tr key={idx} className="border-b border-gray-800 hover:bg-gray-900/50">
                 <td className="px-4 py-3 text-gray-200">{entry.action}</td>
+                <td className="px-4 py-3 text-gray-400">
+                  {entry.version !== undefined ? `v${entry.version}` : "—"}
+                </td>
+                <td className="px-4 py-3 text-gray-400 text-xs">
+                  {entry.diffSummary ? (
+                    <span className="block text-gray-300">{entry.diffSummary}</span>
+                  ) : null}
+                  {entry.amendmentReason ? (
+                    <span className="block text-amber-400">
+                      Reason: {entry.amendmentReason}
+                    </span>
+                  ) : null}
+                  {entry.amendmentComment ? (
+                    <span className="block text-gray-500 italic">
+                      {entry.amendmentComment}
+                    </span>
+                  ) : null}
+                  {!entry.diffSummary && !entry.amendmentReason && !entry.amendmentComment
+                    ? "—"
+                    : null}
+                </td>
                 <td className="px-4 py-3 font-mono text-gray-400 truncate" title={entry.actor}>
                   {truncateAddress(entry.actor)}
                 </td>
diff --git a/src/components/ExportModal.tsx b/src/components/ExportModal.tsx
index 0db0aea6..665dfa20 100644
--- a/src/components/ExportModal.tsx
+++ b/src/components/ExportModal.tsx
@@ -4,6 +4,11 @@ import React, { useState, useCallback } from 'react';
 import type { Invoice } from '@stellar-split/sdk';
 import type { ExportFilterOptions } from '@/lib/invoiceExcelExport';
 import { downloadExcel, generateExportFilename } from '@/lib/invoiceExcelExport';
+import {
+  downloadAgingReportCsv,
+  downloadAgingReportExcel,
+  generateAgingReportFilename,
+} from '@/lib/invoiceAgingExport';
 import { apiFetch } from '@/lib/apiClient';
 
 /** Return a date string in "YYYY-MM-DD" format for an offset of `daysAgo` from today. */
@@ -27,7 +32,9 @@ export default function ExportModal({
   onExport,
 }: ExportModalProps) {
   const [isExporting, setIsExporting] = useState(false);
+  const [isExportingAging, setIsExportingAging] = useState(false);
   const [error, setError] = useState<string | null>(null);
+  const [success, setSuccess] = useState<string | null>(null);
 
   // Date-range state — "From" defaults to 30 days ago, "To" defaults to today
   const [startDate, setStartDate] = useState<string>(() => dateString(30));
@@ -68,30 +75,38 @@ export default function ExportModal({
     return true;
   };
 
+  /** Build the shared filter options from the current modal state. */
+  const buildFilters = useCallback((): ExportFilterOptions => {
+    const filters: ExportFilterOptions = {};
+
+    if (startDate) {
+      filters.startDate = new Date(startDate).getTime() / 1000;
+    }
+    if (endDate) {
+      // Include the full end day by advancing to end-of-day
+      const end = new Date(endDate);
+      end.setHours(23, 59, 59, 999);
+      filters.endDate = end.getTime() / 1000;
+    }
+    if (selectedStatuses.length > 0) {
+      filters.statuses = selectedStatuses;
+    }
+    if (selectedAssets.length > 0) {
+      filters.assets = selectedAssets;
+    }
+
+    return filters;
+  }, [startDate, endDate, selectedStatuses, selectedAssets]);
+
   const handleExport = useCallback(async () => {
     if (!validateDateRange()) return;
 
     setIsExporting(true);
     setError(null);
+    setSuccess(null);
 
     try {
-      const filters: ExportFilterOptions = {};
-
-      if (startDate) {
-        filters.startDate = new Date(startDate).getTime() / 1000;
-      }
-      if (endDate) {
-        // Include the full end day by advancing to end-of-day
-        const end = new Date(endDate);
-        end.setHours(23, 59, 59, 999);
-        filters.endDate = end.getTime() / 1000;
-      }
-      if (selectedStatuses.length > 0) {
-        filters.statuses = selectedStatuses;
-      }
-      if (selectedAssets.length > 0) {
-        filters.assets = selectedAssets;
-      }
+      const filters = buildFilters();
 
       // Build query params so the API route can also filter server-side
       const params = new URLSearchParams();
@@ -143,7 +158,40 @@ export default function ExportModal({
       setIsExporting(false);
     }
   // eslint-disable-next-line react-hooks/exhaustive-deps
-  }, [invoices, startDate, endDate, selectedStatuses, selectedAssets, onExport, onClose]);
+  }, [invoices, buildFilters, startDate, endDate, onExport, onClose]);
+
+  /** Export the aging report (CSV or Excel) using the current filters. */
+  const handleExportAging = useCallback(
+    async (format: 'csv' | 'excel') => {
+      if (!validateDateRange()) return;
+
+      setIsExportingAging(true);
+      setError(null);
+      setSuccess(null);
+
+      try {
+        const filters = buildFilters();
+
+        if (format === 'csv') {
+          downloadAgingReportCsv(invoices, filters);
+        } else {
+          downloadAgingReportExcel(invoices, filters);
+        }
+
+        setSuccess(
+          `Aging report exported as ${generateAgingReportFilename(format)}.`
+        );
+        onExport?.();
+      } catch (err) {
+        setError(
+          err instanceof Error ? err.message : 'Aging report export failed'
+        );
+      } finally {
+        setIsExportingAging(false);
+      }
+    },
+    [invoices, buildFilters, onExport]
+  );
 
   if (!isOpen) return null;
 
@@ -182,11 +230,23 @@ export default function ExportModal({
         {/* Content */}
         <div className="px-6 py-6 space-y-6">
           {error && (
-            <div className="p-4 bg-red-50 border border-red-200 rounded text-sm text-red-800">
+            <div
+              role="alert"
+              className="p-4 bg-red-50 border border-red-200 rounded text-sm text-red-800"
+            >
               {error}
             </div>
           )}
 
+          {success && (
+            <div
+              role="status"
+              className="p-4 bg-green-50 border border-green-200 rounded text-sm text-green-800"
+            >
+              {success}
+            </div>
+          )}
+
           {/* Date Range */}
           <div>
             <label className="block text-sm font-medium text-gray-700 mb-2">
@@ -288,20 +348,49 @@ export default function ExportModal({
               ))}
             </div>
           </div>
+
+          {/* Aging Report Export */}
+          <div>
+            <label className="block text-sm font-medium text-gray-700 mb-2">
+              Aging Report
+            </label>
+            <p className="text-xs text-gray-500 mb-2">
+              Export invoice aging buckets, overdue rates and collection
+              efficiency for the selected date range and filters.
+            </p>
+            <div className="flex gap-2">
+              <button
+                type="button"
+                onClick={() => handleExportAging('csv')}
+                disabled={isExporting || isExportingAging || invoices.length === 0}
+                className="flex-1 px-3 py-2 text-sm text-indigo-700 border border-indigo-300 rounded-lg hover:bg-indigo-50 transition-colors font-medium disabled:opacity-50 disabled:cursor-not-allowed"
+              >
+                {isExportingAging ? 'Exporting...' : 'Export Aging (CSV)'}
+              </button>
+              <button
+                type="button"
+                onClick={() => handleExportAging('excel')}
+                disabled={isExporting || isExportingAging || invoices.length === 0}
+                className="flex-1 px-3 py-2 text-sm text-indigo-700 border border-indigo-300 rounded-lg hover:bg-indigo-50 transition-colors font-medium disabled:opacity-50 disabled:cursor-not-allowed"
+              >
+                {isExportingAging ? 'Exporting...' : 'Export Aging (Excel)'}
+              </button>
+            </div>
+          </div>
         </div>
 
         {/* Footer */}
         <div className="sticky bottom-0 bg-gray-50 border-t border-gray-200 px-6 py-4 flex justify-end gap-4">
           <button
             onClick={onClose}
-            disabled={isExporting}
+            disabled={isExporting || isExportingAging}
             className="px-4 py-2 text-gray-700 border border-gray-300 rounded-lg hover:bg-gray-50 transition-colors font-medium disabled:opacity-50 disabled:cursor-not-allowed"
           >
             Cancel
           </button>
           <button
             onClick={handleExport}
-            disabled={isExporting || invoices.length === 0}
+            disabled={isExporting || isExportingAging || invoices.length === 0}
             className="px-4 py-2 bg-indigo-600 text-white rounded-lg hover:bg-indigo-700 transition-colors font-medium disabled:opacity-50 disabled:cursor-not-allowed"
           >
             {isExporting ? 'Exporting...' : 'Export to Excel'}
diff --git a/src/components/InvoiceTable.tsx b/src/components/InvoiceTable.tsx
index f4ba8ea6..49f5f432 100644
--- a/src/components/InvoiceTable.tsx
+++ b/src/components/InvoiceTable.tsx
@@ -5,21 +5,32 @@ import { useState, useCallback, useMemo, useEffect, useRef } from "react";
 import type { Invoice } from "@stellar-split/sdk";
 import { formatAmount } from "@stellar-split/sdk";
 import { getInvoiceDisplayStatus } from "@/lib/dashboardFilters";
+import {
+  AGING_BUCKETS,
+  getAgingBucket,
+  getDaysOverdue,
+  type AgingBucketKey,
+} from "@/lib/invoiceAging";
 
 // ── Column definitions ────────────────────────────────────────────────────────
 
-export type SortColumn = "id" | "amount" | "status" | "deadline" | "funded";
+export type SortColumn = "id" | "amount" | "status" | "deadline" | "funded" | "aging";
 
-type ColumnKey = "id" | "status" | "amount" | "funded" | "deadline" | "tags" | "recipients";
+type ColumnKey = "id" | "status" | "amount" | "funded" | "deadline" | "aging" | "tags" | "recipients";
 
 const DEFAULT_COLUMNS: Record<ColumnKey, boolean> = {
-  id: true, status: true, amount: true, funded: true, deadline: true, tags: true, recipients: true,
+  id: true, status: true, amount: true, funded: true, deadline: true, aging: false, tags: true, recipients: true,
 };
 
 const COLUMN_LABELS: Record<ColumnKey, string> = {
   id: "ID", status: "Status", amount: "Amount", funded: "Funded",
-  deadline: "Deadline", tags: "Tags", recipients: "Recipients",
+  deadline: "Deadline", aging: "Aging", tags: "Tags", recipients: "Recipients",
 };
+
+const BUCKET_ORDER: Record<AgingBucketKey, number> = AGING_BUCKETS.reduce(
+  (acc, b, i) => ({ ...acc, [b.key]: i }),
+  {} as Record<AgingBucketKey, number>,
+);
 export type SortDir = "asc" | "desc";
 
 export interface InvoiceTableSortState {
@@ -74,6 +85,15 @@ function sortInvoices(
       });
     case "deadline":
       return list.sort((a, b) => mul * (a.deadline - b.deadline));
+    case "aging": {
+      const now = Math.floor(Date.now() / 1000);
+      return list.sort((a, b) => {
+        const ba = BUCKET_ORDER[getAgingBucket(a, now)];
+        const bb = BUCKET_ORDER[getAgingBucket(b, now)];
+        if (ba !== bb) return mul * (ba - bb);
+        return mul * (getDaysOverdue(a, now) - getDaysOverdue(b, now));
+      });
+    }
     case "status": {
       const now = Math.floor(Date.now() / 1000);
       return list.sort(
@@ -167,6 +187,8 @@ interface InvoiceTableProps {
   onSort?: (sort: InvoiceTableSortState) => void;
   /** Content to render in each row's action column */
   rowAction?: (inv: Invoice) => React.ReactNode;
+  /** When set, only invoices in this aging bucket are shown */
+  agingFilter?: AgingBucketKey | null;
 }
 
 /**
@@ -184,6 +206,7 @@ export default function InvoiceTable({
   sort: externalSort,
   onSort: externalOnSort,
   rowAction,
+  agingFilter = null,
 }: InvoiceTableProps) {
   const [internalSort, setInternalSort] =
     useState<InvoiceTableSortState>(DEFAULT_SORT);
@@ -239,7 +262,17 @@ export default function InvoiceTable({
     [sort, externalOnSort],
   );
 
-  const sorted = useMemo(() => sortInvoices(invoices, sort), [invoices, sort]);
+  const now = Math.floor(Date.now() / 1000);
+
+  const filtered = useMemo(
+    () =>
+      agingFilter
+        ? invoices.filter((inv) => getAgingBucket(inv, now) === agingFilter)
+        : invoices,
+    [invoices, agingFilter, now],
+  );
+
+  const sorted = useMemo(() => sortInvoices(filtered, sort), [filtered, sort]);
 
   if (invoices.length === 0) {
     return (
@@ -249,8 +282,6 @@ export default function InvoiceTable({
     );
   }
 
-  const now = Math.floor(Date.now() / 1000);
-
   return (
     <div>
       {/* Gear button + column settings dropdown */}
@@ -312,6 +343,9 @@ export default function InvoiceTable({
               {colVisible.deadline && (
                 <SortHeader column="deadline" label="Deadline" sort={sort} onSort={handleSort} className="w-36" />
               )}
+              {colVisible.aging && (
+                <SortHeader column="aging" label="Aging" sort={sort} onSort={handleSort} className="w-32" />
+              )}
               {colVisible.tags && (
                 <th scope="col" className="text-left px-4 py-3 text-xs font-semibold uppercase tracking-wide text-gray-500">
                   Tags
@@ -416,6 +450,27 @@ export default function InvoiceTable({
                     </td>
                   )}
 
+                  {colVisible.aging && (() => {
+                    const bucket = getAgingBucket(inv, now);
+                    const days = getDaysOverdue(inv, now);
+                    const meta = AGING_BUCKETS.find((b) => b.key === bucket);
+                    return (
+                      <td className="px-4 py-3">
+                        <div className="flex flex-col gap-0.5">
+                          <span
+                            className={`inline-flex w-fit items-center rounded-full px-2 py-0.5 text-[11px] font-semibold ${meta?.className ?? "bg-gray-500/20 text-gray-400"}`}
+                            aria-label={`Aging bucket: ${meta?.label ?? bucket}`}
+                          >
+                            {meta?.label ?? bucket}
+                          </span>
+                          {days > 0 && (
+                            <span className="text-[11px] text-amber-400">{days}d overdue</span>
+                          )}
+                        </div>
+                      </td>
+                    );
+                  })()}
+
                   {colVisible.tags && (
                     <td className="px-4 py-3">
                       {tags.length > 0 ? (
diff --git a/src/components/InvoiceTimeline.tsx b/src/components/InvoiceTimeline.tsx
index 65d75652..9bb68518 100644
--- a/src/components/InvoiceTimeline.tsx
+++ b/src/components/InvoiceTimeline.tsx
@@ -15,11 +15,19 @@ export interface InvoiceEvent {
     | 'DisputeRaised'
     | 'DisputeResolved'
     | 'Frozen'
-    | 'Archived';
+    | 'Archived'
+    | 'Amended'
+    | 'VersionRestored';
   description: string;
   actor?: string;
   timestamp: number; // unix seconds
   txHash?: string;
+  /** Version number produced by this event, if applicable. */
+  version?: number;
+  /** Human-readable reason supplied for an amendment. */
+  amendmentReason?: string;
+  /** Optional free-form comment accompanying an amendment. */
+  amendmentComment?: string;
 }
 
 interface Props {
@@ -44,6 +52,8 @@ const EVENT_META: Record<
   DisputeResolved: { icon: '🤝', color: 'text-green-400', dot: 'bg-green-500' },
   Frozen: { icon: '🧊', color: 'text-orange-400', dot: 'bg-orange-500' },
   Archived: { icon: '📦', color: 'text-gray-400', dot: 'bg-gray-500' },
+  Amended: { icon: '✏️', color: 'text-indigo-400', dot: 'bg-indigo-500' },
+  VersionRestored: { icon: '⏪', color: 'text-purple-400', dot: 'bg-purple-500' },
 };
 
 async function fetchEvents(invoiceId: string, cursor?: string): Promise<{ events: InvoiceEvent[]; nextCursor?: string }> {
@@ -150,7 +160,12 @@ export default function InvoiceTimeline({ invoiceId }: Props) {
         {events.map((evt, i) => {
           const meta = EVENT_META[evt.type] ?? EVENT_META.Created;
           const isExpanded = expandedIndices.has(i);
-          const hasDetails = evt.actor || evt.txHash;
+          const hasDetails =
+            evt.actor ||
+            evt.txHash ||
+            evt.version !== undefined ||
+            evt.amendmentReason ||
+            evt.amendmentComment;
           return (
             <li key={i} className="pl-6 relative">
               {/* dot */}
@@ -162,9 +177,19 @@ export default function InvoiceTimeline({ invoiceId }: Props) {
                 <span className={`font-medium text-sm ${meta.color}`}>
                   {meta.icon} {evt.type.replace(/([A-Z])/g, ' $1').trim()}
                 </span>
+                {evt.version !== undefined && (
+                  <span className="text-xs font-mono text-gray-500 bg-gray-800 border border-gray-700 rounded px-1.5 py-0.5">
+                    v{evt.version}
+                  </span>
+                )}
                 <RelativeTime iso={new Date(evt.timestamp * 1000).toISOString()} className="text-xs text-gray-500 cursor-default" />
               </div>
               <p className="text-xs text-gray-400 mt-0.5">{evt.description}</p>
+              {evt.amendmentReason && (
+                <p className="text-xs text-indigo-300 mt-1">
+                  <span className="text-gray-500">Reason:</span> {evt.amendmentReason}
+                </p>
+              )}
 
               {hasDetails && (
                 <button
@@ -184,6 +209,11 @@ export default function InvoiceTimeline({ invoiceId }: Props) {
                 }}
                 className={`timeline-details ${isExpanded ? 'expanded' : 'collapsed'}`}
               >
+                {evt.amendmentComment && (
+                  <div className="mt-2 text-xs text-gray-400 bg-gray-800/60 border border-gray-700 rounded-lg px-3 py-2 whitespace-pre-wrap">
+                    {evt.amendmentComment}
+                  </div>
+                )}
                 {evt.actor && (
                   <div className="mt-2">
                     <WalletAddress address={evt.actor} truncate showCopy />
diff --git a/src/components/VersionHistory.tsx b/src/components/VersionHistory.tsx
index 4f47f428..6ba7bfcd 100644
--- a/src/components/VersionHistory.tsx
+++ b/src/components/VersionHistory.tsx
@@ -4,6 +4,12 @@ import { useEffect, useState } from "react";
 import { splitClient } from "@/lib/stellar";
 import { truncateAddress } from "@stellar-split/sdk";
 import RelativeTime from "@/components/ui/RelativeTime";
+import {
+  getInvoiceVersions,
+  notifyAffectedParties,
+  type InvoiceVersion,
+  type InvoiceVersionDiff,
+} from "@/lib/invoiceVersioning";
 
 interface HistoryEntry {
   action: string;
@@ -13,6 +19,12 @@ interface HistoryEntry {
   address?: string;
   /** Structured diff for the expanded diff view (issue #606). */
   diff?: FieldDiff[];
+  /** Amendment reason recorded with the version (issue #937). */
+  reason?: string;
+  /** Free-form amendment comment recorded with the version (issue #937). */
+  comment?: string;
+  /** Author of the amendment (issue #937). */
+  author?: string;
 }
 
 /** A single field change shown in the diff panel. */
@@ -134,6 +146,28 @@ function buildDiff(entry: any): FieldDiff[] {
   return diffs;
 }
 
+// ─── Version mapping ─────────────────────────────────────────────────────────
+
+/** Map a stored invoice version into the timeline entry shape. */
+function mapVersionToEntry(version: InvoiceVersion): HistoryEntry {
+  const diff: FieldDiff[] = (version.diff ?? []).map((d: InvoiceVersionDiff) => ({
+    field: d.field,
+    before: d.before,
+    after: d.after,
+  }));
+
+  return {
+    action: version.action
+      ? version.action.replace(/_/g, " ").charAt(0).toUpperCase() + version.action.slice(1)
+      : "Amendment",
+    timestamp: version.timestamp,
+    diff,
+    reason: version.reason,
+    comment: version.comment,
+    author: version.author,
+  };
+}
+
 // ─── DiffPanel ────────────────────────────────────────────────────────────────
 
 function DiffPanel({ diffs }: { diffs: FieldDiff[] }) {
@@ -384,48 +418,74 @@ export default function VersionHistory({ invoiceId, onRestore }: Props) {
     const loadHistory = async () => {
       try {
         setLoading(true);
-        const auditLog = await (splitClient as any).getAuditLog(invoiceId);
 
-        if (!auditLog || auditLog.length === 0) {
-          setHistory([]);
-          return;
+        // Prefer the versioned store; fall back to the raw audit log.
+        let entries: HistoryEntry[] = [];
+        try {
+          const versions = await getInvoiceVersions(invoiceId);
+          if (versions && versions.length > 0) {
+            entries = versions.map(mapVersionToEntry);
+          }
+        } catch {
+          // Version store unavailable — fall through to audit log.
         }
 
-        const entries: HistoryEntry[] = auditLog.map((entry: any) => {
-          const action = entry.action || entry.type;
-          const timestamp = entry.timestamp || entry.createdAt;
+        if (entries.length === 0) {
+          const auditLog = await (splitClient as any).getAuditLog(invoiceId);
+
+          if (!auditLog || auditLog.length === 0) {
+            setHistory([]);
+            return;
+          }
+
+          entries = auditLog.map((entry: any) => {
+            const action = entry.action || entry.type;
+            const timestamp = entry.timestamp || entry.createdAt;
+
+            if (action === "extend_deadline") {
+              return {
+                action: "Deadline Extended",
+                timestamp,
+                oldValue: new Date(entry.oldDeadline * 1000).toLocaleDateString(),
+                newValue: new Date(entry.newDeadline * 1000).toLocaleDateString(),
+                diff: buildDiff(entry),
+                reason: entry.reason,
+                comment: entry.comment,
+                author: entry.author,
+              };
+            } else if (action === "add_co_creator") {
+              return {
+                action: "Co-creator Added",
+                timestamp,
+                address: entry.address,
+                diff: buildDiff(entry),
+                reason: entry.reason,
+                comment: entry.comment,
+                author: entry.author,
+              };
+            } else if (action === "remove_co_creator") {
+              return {
+                action: "Co-creator Removed",
+                timestamp,
+                address: entry.address,
+                diff: buildDiff(entry),
+                reason: entry.reason,
+                comment: entry.comment,
+                author: entry.author,
+              };
+            }
 
-          if (action === "extend_deadline") {
-            return {
-              action: "Deadline Extended",
-              timestamp,
-              oldValue: new Date(entry.oldDeadline * 1000).toLocaleDateString(),
-              newValue: new Date(entry.newDeadline * 1000).toLocaleDateString(),
-              diff: buildDiff(entry),
-            };
-          } else if (action === "add_co_creator") {
-            return {
-              action: "Co-creator Added",
-              timestamp,
-              address: entry.address,
-              diff: buildDiff(entry),
-            };
-          } else if (action === "remove_co_creator") {
             return {
-              action: "Co-creator Removed",
+              action:
+                action.replace(/_/g, " ").charAt(0).toUpperCase() + action.slice(1),
               timestamp,
-              address: entry.address,
               diff: buildDiff(entry),
+              reason: entry.reason,
+              comment: entry.comment,
+              author: entry.author,
             };
-          }
-
-          return {
-            action:
-              action.replace(/_/g, " ").charAt(0).toUpperCase() + action.slice(1),
-            timestamp,
-            diff: buildDiff(entry),
-          };
-        });
+          });
+        }
 
         setHistory(entries.sort((a, b) => b.timestamp - a.timestamp));
       } catch (err) {
@@ -463,6 +523,18 @@ export default function VersionHistory({ invoiceId, onRestore }: Props) {
     if (onRestore) {
       onRestore(restoreIndex, entry);
     }
+
+    // Notify affected parties (creator, recipients, payers) of the amendment.
+    void notifyAffectedParties(invoiceId, {
+      action: "restore_version",
+      versionNumber: entry.versionNumber,
+      reason: entry.reason,
+      comment: entry.comment,
+      diff: entry.diff,
+    }).catch(() => {
+      // Notification failures must not block the restore flow.
+    });
+
     setRestoreNotice(
       `Version ${entry.versionNumber} (${entry.action}) has been queued for restore. A new history entry will be created.`
     );
@@ -635,8 +707,31 @@ export default function VersionHistory({ invoiceId, onRestore }: Props) {
                   <RelativeTime
                     iso={new Date(entry.timestamp * 1000).toISOString()}
                   />
+                  {entry.author && (
+                    <span className="ml-2 text-gray-500">
+                      by <span className="font-mono">{truncateAddress(entry.author)}</span>
+                    </span>
+                  )}
                 </p>
 
+                {/* Amendment reason & comment (issue #937) */}
+                {(entry.reason || entry.comment) && (
+                  <div className="mt-2 rounded-lg border border-gray-700 bg-gray-800/40 px-3 py-2 text-xs">
+                    {entry.reason && (
+                      <p className="text-gray-300">
+                        <span className="font-semibold text-gray-400">Reason: </span>
+                        {entry.reason}
+                      </p>
+                    )}
+                    {entry.comment && (
+                      <p className="text-gray-400 mt-1">
+                        <span className="font-semibold text-gray-500">Comment: </span>
+                        {entry.comment}
+                      </p>
+                    )}
+                  </div>
+                )}
+
                 {/* Legacy inline diff (always shown for extend_deadline) */}
                 {entry.oldValue && entry.newValue && !isExpanded && (
                   <div className="mt-2 text-sm space-y-1">
diff --git a/src/hooks/useInvoices.ts b/src/hooks/useInvoices.ts
index e78d3ace..76f719a9 100644
--- a/src/hooks/useInvoices.ts
+++ b/src/hooks/useInvoices.ts
@@ -9,6 +9,7 @@ import {
   QuotaExceededCacheError,
 } from "@/lib/db/invoiceCache";
 import { useToast } from "@/contexts/ToastContext";
+import { trackEvent } from "@/lib/analytics";
 
 export interface UseInvoicesResult {
   invoices: Invoice[];
@@ -45,6 +46,9 @@ export function useInvoices(publicKey: string | null | undefined): UseInvoicesRe
       return;
     }
 
+    // Fire-and-forget: never await analytics so the data fetch is not delayed.
+    trackEvent("wallet_connected");
+
     setLoading(true);
     setRefreshing(true);
 
@@ -65,6 +69,22 @@ export function useInvoices(publicKey: string | null | undefined): UseInvoicesRe
         if (!active) return;
         setInvoices(data.invoices);
         setError(null);
+
+        // Fire-and-forget analytics with non-identifying custom properties.
+        const statusBreakdown: Record<string, number> = {};
+        for (const invoice of data.invoices) {
+          const status = String(invoice.status ?? "unknown");
+          statusBreakdown[status] = (statusBreakdown[status] ?? 0) + 1;
+        }
+        trackEvent("invoice_list_viewed", {
+          count: data.invoices.length,
+          statusBreakdown,
+        });
+        for (const invoice of data.invoices) {
+          trackEvent("invoice_created", {
+            status: String(invoice.status ?? "unknown"),
+          });
+        }
         try {
           await putCachedInvoices(publicKey, data.invoices);
         } catch (err) {
diff --git a/src/lib/analytics.ts b/src/lib/analytics.ts
new file mode 100644
index 00000000..9a1e4e6b
--- /dev/null
+++ b/src/lib/analytics.ts
@@ -0,0 +1,285 @@
+/**
+ * Privacy-preserving analytics module.
+ *
+ * - All tracking is gated behind explicit user consent (persisted in localStorage).
+ * - Events are batched and flushed asynchronously (sendBeacon / fetch keepalive)
+ *   so tracking never blocks the UI.
+ * - PII (emails, addresses) is stripped from event payloads before sending.
+ */
+
+export type AnalyticsEventName =
+  | 'app_opened'
+  | 'page_view'
+  | 'wallet_connected'
+  | 'wallet_disconnected'
+  | 'transaction_initiated'
+  | 'transaction_completed'
+  | 'transaction_failed'
+  | 'search_performed'
+  | 'filter_applied'
+  | 'settings_changed'
+  | 'feature_used'
+  | 'error_occurred';
+
+export interface AnalyticsProperties {
+  /** Arbitrary string properties. PII is stripped before sending. */
+  [key: string]: string | number | boolean | null | undefined;
+}
+
+export interface AnalyticsEvent {
+  name: AnalyticsEventName;
+  properties: AnalyticsProperties;
+  timestamp: number;
+}
+
+export type ConsentStatus = 'granted' | 'denied' | 'unset';
+
+const CONSENT_STORAGE_KEY = 'analytics_consent';
+const BATCH_SIZE = 20;
+const FLUSH_INTERVAL_MS = 10_000;
+const MAX_QUEUE_SIZE = 200;
+
+const EMAIL_REGEX = /[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}/g;
+// Matches typical street addresses (number followed by words and a street suffix).
+const ADDRESS_REGEX =
+  /\b\d{1,6}\s+[A-Za-z0-9.'-]+(?:\s+[A-Za-z0-9.'-]+){0,4}\s+(?:street|st|avenue|ave|road|rd|boulevard|blvd|lane|ln|drive|dr|court|ct|way|place|pl|terrace|ter|circle|cir|highway|hwy|parkway|pkwy)\b\.?/gi;
+// Matches common crypto wallet addresses (EVM + Solana-like base58).
+const WALLET_REGEX = /\b(?:0x[a-fA-F0-9]{40}|[1-9A-HJ-NP-Za-km-z]{32,44})\b/g;
+
+let queue: AnalyticsEvent[] = [];
+let flushTimer: ReturnType<typeof setInterval> | null = null;
+let initialized = false;
+let endpoint = '/api/analytics/events';
+let globalProperties: AnalyticsProperties = {};
+
+function isBrowser(): boolean {
+  return typeof window !== 'undefined' && typeof window.localStorage !== 'undefined';
+}
+
+function safeGetItem(key: string): string | null {
+  try {
+    return window.localStorage.getItem(key);
+  } catch {
+    return null;
+  }
+}
+
+function safeSetItem(key: string, value: string): void {
+  try {
+    window.localStorage.setItem(key, value);
+  } catch {
+    // Storage may be unavailable (private mode, quota); fail silently.
+  }
+}
+
+/**
+ * Returns the current consent status. Defaults to 'unset' when no decision
+ * has been recorded.
+ */
+export function getConsent(): ConsentStatus {
+  if (!isBrowser()) {
+    return 'unset';
+  }
+  const stored = safeGetItem(CONSENT_STORAGE_KEY);
+  if (stored === 'granted' || stored === 'denied') {
+    return stored;
+  }
+  return 'unset';
+}
+
+/**
+ * Records the user's consent decision. When consent is revoked, any queued
+ * events are discarded and the flush timer is stopped.
+ */
+export function setConsent(status: 'granted' | 'denied'): void {
+  if (!isBrowser()) {
+    return;
+  }
+  safeSetItem(CONSENT_STORAGE_KEY, status);
+
+  if (status === 'denied') {
+    queue = [];
+    stopFlushTimer();
+  } else if (status === 'granted' && initialized) {
+    startFlushTimer();
+  }
+}
+
+function hasConsent(): boolean {
+  return getConsent() === 'granted';
+}
+
+/**
+ * Removes PII (emails, addresses, wallet addresses) from a string value.
+ */
+function stripPiiFromString(value: string): string {
+  return value
+    .replace(EMAIL_REGEX, '[redacted-email]')
+    .replace(ADDRESS_REGEX, '[redacted-address]')
+    .replace(WALLET_REGEX, '[redacted-wallet]');
+}
+
+/**
+ * Recursively sanitizes a property value, stripping PII from strings.
+ */
+function sanitizeValue(value: unknown): string | number | boolean | null | undefined {
+  if (typeof value === 'string') {
+    return stripPiiFromString(value);
+  }
+  if (
+    typeof value === 'number' ||
+    typeof value === 'boolean' ||
+    value === null ||
+    value === undefined
+  ) {
+    return value;
+  }
+  // Drop non-primitive values to avoid leaking unexpected data.
+  return undefined;
+}
+
+function sanitizeProperties(properties: AnalyticsProperties): AnalyticsProperties {
+  const sanitized: AnalyticsProperties = {};
+  for (const [key, value] of Object.entries(properties)) {
+    const cleanValue = sanitizeValue(value);
+    if (cleanValue !== undefined) {
+      sanitized[key] = cleanValue;
+    }
+  }
+  return sanitized;
+}
+
+function startFlushTimer(): void {
+  if (flushTimer !== null || !isBrowser()) {
+    return;
+  }
+  flushTimer = setInterval(() => {
+    void flush();
+  }, FLUSH_INTERVAL_MS);
+}
+
+function stopFlushTimer(): void {
+  if (flushTimer !== null) {
+    clearInterval(flushTimer);
+    flushTimer = null;
+  }
+}
+
+/**
+ * Sends a batch of events without blocking the UI. Prefers sendBeacon and
+ * falls back to fetch with keepalive.
+ */
+function sendBatch(events: AnalyticsEvent[]): void {
+  if (events.length === 0 || !isBrowser()) {
+    return;
+  }
+
+  const payload = JSON.stringify({ events });
+
+  try {
+    if (typeof navigator !== 'undefined' && typeof navigator.sendBeacon === 'function') {
+      const blob = new Blob([payload], { type: 'application/json' });
+      const sent = navigator.sendBeacon(endpoint, blob);
+      if (sent) {
+        return;
+      }
+    }
+  } catch {
+    // Fall through to fetch.
+  }
+
+  try {
+    void fetch(endpoint, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: payload,
+      keepalive: true,
+    }).catch(() => {
+      // Network failures are non-fatal for analytics.
+    });
+  } catch {
+    // Ignore; analytics must never throw into app code.
+  }
+}
+
+/**
+ * Flushes all queued events. Safe to call at any time; no-op without consent.
+ */
+export async function flush(): Promise<void> {
+  if (!hasConsent() || queue.length === 0) {
+    return;
+  }
+  const batch = queue;
+  queue = [];
+  sendBatch(batch);
+}
+
+/**
+ * Initializes the analytics module. Idempotent.
+ *
+ * @param options.endpoint - Custom ingestion endpoint.
+ * @param options.properties - Global custom properties attached to every event.
+ */
+export function initAnalytics(options?: {
+  endpoint?: string;
+  properties?: AnalyticsProperties;
+}): void {
+  if (!isBrowser()) {
+    return;
+  }
+  if (options?.endpoint) {
+    endpoint = options.endpoint;
+  }
+  if (options?.properties) {
+    globalProperties = { ...globalProperties, ...sanitizeProperties(options.properties) };
+  }
+
+  if (initialized) {
+    return;
+  }
+  initialized = true;
+
+  if (hasConsent()) {
+    startFlushTimer();
+  }
+
+  // Flush remaining events when the page is being hidden/unloaded.
+  window.addEventListener('visibilitychange', () => {
+    if (document.visibilityState === 'hidden') {
+      void flush();
+    }
+  });
+  window.addEventListener('pagehide', () => {
+    void flush();
+  });
+}
+
+/**
+ * Tracks a user action. No-op unless the user has granted consent.
+ * Events are queued and flushed asynchronously in batches.
+ */
+export function trackEvent(
+  name: AnalyticsEventName,
+  properties: AnalyticsProperties = {},
+): void {
+  if (!isBrowser() || !hasConsent()) {
+    return;
+  }
+
+  const event: AnalyticsEvent = {
+    name,
+    properties: sanitizeProperties({ ...globalProperties, ...properties }),
+    timestamp: Date.now(),
+  };
+
+  queue.push(event);
+
+  // Bound memory usage if flushing is failing or slow.
+  if (queue.length > MAX_QUEUE_SIZE) {
+    queue = queue.slice(queue.length - MAX_QUEUE_SIZE);
+  }
+
+  if (queue.length >= BATCH_SIZE) {
+    void flush();
+  }
+}
\ No newline at end of file
diff --git a/src/lib/apiClient.ts b/src/lib/apiClient.ts
index c1faa06a..807383b8 100644
--- a/src/lib/apiClient.ts
+++ b/src/lib/apiClient.ts
@@ -10,6 +10,66 @@
 
 const MUTATING_METHODS = new Set(["POST", "PUT", "PATCH", "DELETE"]);
 
+/**
+ * Analytics hook. Kept as a lightweight, fire-and-forget emitter so the API
+ * client has no hard dependency on a specific analytics provider. Query
+ * strings and request bodies are never forwarded; only the path template,
+ * method, status code and duration are reported.
+ */
+export type ApiRequestEvent = {
+  method: string;
+  path: string;
+  status: number;
+  durationMs: number;
+};
+
+type ApiRequestTracker = (event: ApiRequestEvent) => void;
+
+let apiRequestTracker: ApiRequestTracker | null = null;
+
+export function setApiRequestTracker(tracker: ApiRequestTracker | null): void {
+  apiRequestTracker = tracker;
+}
+
+function toPathTemplate(input: RequestInfo | URL): string {
+  let raw: string;
+  if (typeof input === "string") {
+    raw = input;
+  } else if (input instanceof URL) {
+    raw = input.pathname;
+  } else {
+    raw = input.url;
+  }
+
+  // Strip query string / fragment so no user-supplied parameters leak.
+  const withoutQuery = raw.split(/[?#]/, 1)[0] ?? "";
+
+  // Reduce absolute URLs to their pathname.
+  if (/^https?:\/\//i.test(withoutQuery)) {
+    try {
+      return new URL(withoutQuery).pathname;
+    } catch {
+      return withoutQuery;
+    }
+  }
+  return withoutQuery;
+}
+
+function trackApiRequest(event: ApiRequestEvent): void {
+  if (!apiRequestTracker) {
+    return;
+  }
+  // Schedule after the current task so tracking never delays the response,
+  // and swallow any errors so analytics can't break the caller.
+  setTimeout(() => {
+    try {
+      apiRequestTracker?.(event);
+    } catch {
+      // Intentionally ignored: analytics must never throw into the caller.
+    }
+  }, 0);
+}
+
 // Refresh a little early so a request that starts right before expiry
 // doesn't race the server-side clock.
 const REFRESH_SKEW_MS = 60 * 1000;
@@ -58,6 +118,9 @@ export async function apiFetch(input: RequestInfo | URL, init: RequestInit = {})
     return fetch(input, init);
   }
 
+  const path = toPathTemplate(input);
+  const startedAt = Date.now();
+
   const attempt = async (token: string) => {
     const headers = new Headers(init.headers);
     headers.set("X-CSRF-Token", token);
@@ -67,9 +130,12 @@ export async function apiFetch(input: RequestInfo | URL, init: RequestInit = {})
   const token = await getCsrfToken();
   const response = await attempt(token);
   if (response.status !== 403) {
+    trackApiRequest({ method, path, status: response.status, durationMs: Date.now() - startedAt });
     return response;
   }
 
   const freshToken = await getCsrfToken(true);
-  return attempt(freshToken);
+  const retryResponse = await attempt(freshToken);
+  trackApiRequest({ method, path, status: retryResponse.status, durationMs: Date.now() - startedAt });
+  return retryResponse;
 }
diff --git a/src/lib/auditLog.ts b/src/lib/auditLog.ts
index fac8627e..3628776f 100644
--- a/src/lib/auditLog.ts
+++ b/src/lib/auditLog.ts
@@ -31,6 +31,55 @@ export function filterAuditEntries(entries: AuditEntry[], filter: AuditFilter =
     .sort((a, b) => b.timestamp - a.timestamp);
 }
 
+export interface InvoiceAmendmentAuditInput {
+  id: string;
+  timestamp?: number;
+  actor: string;
+  invoiceId: string;
+  reason: string;
+  changedFields: string[];
+  comment?: string;
+  version?: number;
+}
+
+export function createInvoiceAmendmentAuditEntry(input: InvoiceAmendmentAuditInput): AuditEntry {
+  const parts: string[] = [`Reason: ${input.reason}`];
+  if (input.changedFields.length > 0) {
+    parts.push(`Changed fields: ${input.changedFields.join(", ")}`);
+  }
+  if (input.version !== undefined) {
+    parts.push(`Version: ${input.version}`);
+  }
+  if (input.comment) {
+    parts.push(`Comment: ${input.comment}`);
+  }
+  return {
+    id: input.id,
+    timestamp: input.timestamp ?? Date.now(),
+    actor: input.actor,
+    action: "invoice_amended",
+    category: "invoice",
+    target: input.invoiceId,
+    details: parts.join(" | "),
+  };
+}
+
+export function appendInvoiceAmendmentAuditEntry(
+  entries: AuditEntry[],
+  input: InvoiceAmendmentAuditInput,
+): AuditEntry[] {
+  return [...entries, createInvoiceAmendmentAuditEntry(input)];
+}
+
+export function filterAuditEntriesByInvoice(
+  entries: AuditEntry[],
+  invoiceId: string,
+): AuditEntry[] {
+  return entries
+    .filter((e) => e.category === "invoice" && e.target === invoiceId)
+    .sort((a, b) => b.timestamp - a.timestamp);
+}
+
 function csvCell(value: string): string {
   return /[",\n]/.test(value) ? `"${value.replace(/"/g, '""')}"` : value;
 }
@@ -43,4 +92,4 @@ export function auditEntriesToCsv(entries: AuditEntry[]): string {
       .join(","),
   );
   return [header, ...rows].join("\n");
-}
+}
\ No newline at end of file
diff --git a/src/lib/backup.ts b/src/lib/backup.ts
new file mode 100644
index 00000000..94049878
--- /dev/null
+++ b/src/lib/backup.ts
@@ -0,0 +1,322 @@
+import { createHash } from 'crypto';
+
+/**
+ * Backup and disaster recovery module.
+ *
+ * Implements the automated backup routine for the invoice cache and audit
+ * data. Backups are written to a primary storage target and a geo-replica
+ * target, verified after upload, and failures are reported via
+ * `notifyBackupFailure`.
+ *
+ * This module is invoked by the scheduler registered in `instrumentation.ts`.
+ */
+
+export interface BackupStorageTarget {
+  /** Human readable identifier for the storage target. */
+  name: string;
+  /** Whether this target is the geo-redundant replica. */
+  geoReplica?: boolean;
+  /** Upload a serialized backup payload and return the stored object key. */
+  upload: (key: string, payload: Buffer) => Promise<string>;
+  /** Download a previously stored backup payload by key. */
+  download: (key: string) => Promise<Buffer>;
+  /** Check whether an object exists in the target. */
+  exists?: (key: string) => Promise<boolean>;
+}
+
+export interface BackupConfig {
+  /** Primary storage target. */
+  primary: BackupStorageTarget;
+  /** Geo-redundant replica storage target. */
+  geoReplica: BackupStorageTarget;
+  /** Optional prefix for object keys. */
+  keyPrefix?: string;
+  /** Optional clock override for deterministic tests. */
+  now?: () => Date;
+}
+
+export interface BackupSnapshot {
+  version: number;
+  createdAt: string;
+  invoiceCache: unknown;
+  auditData: unknown;
+}
+
+export interface BackupResult {
+  success: boolean;
+  key: string;
+  createdAt: string;
+  checksum: string;
+  size: number;
+  primaryLocation?: string;
+  geoReplicaLocation?: string;
+  error?: string;
+}
+
+export interface RestorationVerificationResult {
+  success: boolean;
+  key: string;
+  checksum: string;
+  expectedChecksum?: string;
+  size: number;
+  snapshot?: BackupSnapshot;
+  error?: string;
+}
+
+/**
+ * Loads the invoice cache data that should be included in the backup.
+ * Replace the body with the real data source accessor.
+ */
+async function loadInvoiceCache(): Promise<unknown> {
+  // TODO: wire up to the actual invoice cache store.
+  return {};
+}
+
+/**
+ * Loads the audit data that should be included in the backup.
+ * Replace the body with the real data source accessor.
+ */
+async function loadAuditData(): Promise<unknown> {
+  // TODO: wire up to the actual audit data store.
+  return {};
+}
+
+/**
+ * Reports a backup failure to the alerting system.
+ * Replace the body with the real alerting integration.
+ */
+export async function notifyBackupFailure(
+  error: Error,
+  context: { key?: string; target?: string; phase?: string },
+): Promise<void> {
+  // TODO: wire up to the alerting/monitoring provider.
+  // eslint-disable-next-line no-console
+  console.error('[backup] failure', {
+    message: error.message,
+    stack: error.stack,
+    ...context,
+  });
+}
+
+function computeChecksum(payload: Buffer): string {
+  return createHash('sha256').update(payload).digest('hex');
+}
+
+function buildBackupKey(prefix: string | undefined, createdAt: Date): string {
+  const timestamp = createdAt.toISOString().replace(/[:.]/g, '-');
+  const base = `backups/${timestamp}.json`;
+  return prefix ? `${prefix.replace(/\/+$/, '')}/${base}` : base;
+}
+
+async function createSnapshot(now: () => Date): Promise<BackupSnapshot> {
+  const [invoiceCache, auditData] = await Promise.all([
+    loadInvoiceCache(),
+    loadAuditData(),
+  ]);
+
+  return {
+    version: 1,
+    createdAt: now().toISOString(),
+    invoiceCache,
+    auditData,
+  };
+}
+
+async function uploadAndVerify(
+  target: BackupStorageTarget,
+  key: string,
+  payload: Buffer,
+  checksum: string,
+): Promise<string> {
+  const location = await target.upload(key, payload);
+
+  if (target.exists) {
+    const present = await target.exists(key);
+    if (!present) {
+      throw new Error(`Upload verification failed: object missing at ${target.name}`);
+    }
+  }
+
+  const downloaded = await target.download(key);
+  const downloadedChecksum = computeChecksum(downloaded);
+  if (downloadedChecksum !== checksum) {
+    throw new Error(
+      `Upload verification failed: checksum mismatch at ${target.name}`,
+    );
+  }
+
+  return location;
+}
+
+/**
+ * Runs the automated backup routine.
+ *
+ * Snapshots the invoice cache and audit data, uploads the payload to the
+ * primary and geo-replica storage targets, verifies each upload, and reports
+ * failures via `notifyBackupFailure`.
+ */
+export async function runBackup(config: BackupConfig): Promise<BackupResult> {
+  const now = config.now ?? (() => new Date());
+  const createdAt = now();
+  const key = buildBackupKey(config.keyPrefix, createdAt);
+
+  let payload: Buffer;
+  let checksum: string;
+
+  try {
+    const snapshot = await createSnapshot(now);
+    payload = Buffer.from(JSON.stringify(snapshot), 'utf8');
+    checksum = computeChecksum(payload);
+  } catch (err) {
+    const error = err instanceof Error ? err : new Error(String(err));
+    await notifyBackupFailure(error, { key, phase: 'snapshot' });
+    return {
+      success: false,
+      key,
+      createdAt: createdAt.toISOString(),
+      checksum: '',
+      size: 0,
+      error: error.message,
+    };
+  }
+
+  let primaryLocation: string | undefined;
+  let geoReplicaLocation: string | undefined;
+
+  try {
+    primaryLocation = await uploadAndVerify(
+      config.primary,
+      key,
+      payload,
+      checksum,
+    );
+  } catch (err) {
+    const error = err instanceof Error ? err : new Error(String(err));
+    await notifyBackupFailure(error, {
+      key,
+      target: config.primary.name,
+      phase: 'primary-upload',
+    });
+    return {
+      success: false,
+      key,
+      createdAt: createdAt.toISOString(),
+      checksum,
+      size: payload.length,
+      error: error.message,
+    };
+  }
+
+  try {
+    geoReplicaLocation = await uploadAndVerify(
+      config.geoReplica,
+      key,
+      payload,
+      checksum,
+    );
+  } catch (err) {
+    const error = err instanceof Error ? err : new Error(String(err));
+    await notifyBackupFailure(error, {
+      key,
+      target: config.geoReplica.name,
+      phase: 'geo-replica-upload',
+    });
+    return {
+      success: false,
+      key,
+      createdAt: createdAt.toISOString(),
+      checksum,
+      size: payload.length,
+      primaryLocation,
+      error: error.message,
+    };
+  }
+
+  return {
+    success: true,
+    key,
+    createdAt: createdAt.toISOString(),
+    checksum,
+    size: payload.length,
+    primaryLocation,
+    geoReplicaLocation,
+  };
+}
+
+/**
+ * Verifies that a backup can be restored from the given storage target.
+ *
+ * Downloads the backup, validates its checksum (against the expected value
+ * when provided), and parses the snapshot. Used by disaster recovery drills.
+ */
+export async function verifyRestoration(
+  target: BackupStorageTarget,
+  key: string,
+  expectedChecksum?: string,
+): Promise<RestorationVerificationResult> {
+  try {
+    const payload = await target.download(key);
+    const checksum = computeChecksum(payload);
+
+    if (expectedChecksum && checksum !== expectedChecksum) {
+      return {
+        success: false,
+        key,
+        checksum,
+        expectedChecksum,
+        size: payload.length,
+        error: 'Checksum mismatch during restoration verification',
+      };
+    }
+
+    let snapshot: BackupSnapshot;
+    try {
+      snapshot = JSON.parse(payload.toString('utf8')) as BackupSnapshot;
+    } catch (err) {
+      const error = err instanceof Error ? err : new Error(String(err));
+      return {
+        success: false,
+        key,
+        checksum,
+        expectedChecksum,
+        size: payload.length,
+        error: `Failed to parse backup payload: ${error.message}`,
+      };
+    }
+
+    if (
+      !snapshot ||
+      typeof snapshot !== 'object' ||
+      !('invoiceCache' in snapshot) ||
+      !('auditData' in snapshot)
+    ) {
+      return {
+        success: false,
+        key,
+        checksum,
+        expectedChecksum,
+        size: payload.length,
+        error: 'Backup payload is missing required sections',
+      };
+    }
+
+    return {
+      success: true,
+      key,
+      checksum,
+      expectedChecksum,
+      size: payload.length,
+      snapshot,
+    };
+  } catch (err) {
+    const error = err instanceof Error ? err : new Error(String(err));
+    return {
+      success: false,
+      key,
+      checksum: '',
+      expectedChecksum,
+      size: 0,
+      error: error.message,
+    };
+  }
+}
\ No newline at end of file
diff --git a/src/lib/config.ts b/src/lib/config.ts
index 84a271b0..bfbe4f51 100644
--- a/src/lib/config.ts
+++ b/src/lib/config.ts
@@ -15,10 +15,81 @@ export const RPC_URL =
 /** StellarSplit contract ID used for on-chain calls and event filtering. */
 export const contractId = process.env.NEXT_PUBLIC_CONTRACT_ID ?? "";
 
+/**
+ * Analytics configuration.
+ *
+ * Env vars:
+ *   NEXT_PUBLIC_ANALYTICS_ENABLED  - "true" to enable client-side analytics
+ *   NEXT_PUBLIC_ANALYTICS_PROVIDER - provider name (e.g. "posthog", "plausible")
+ *   NEXT_PUBLIC_ANALYTICS_ENDPOINT - ingestion / API endpoint for the provider
+ *   NEXT_PUBLIC_ANALYTICS_SAMPLE_RATE - sampling rate in [0, 1] (default 1)
+ */
+export const ANALYTICS_ENABLED =
+  process.env.NEXT_PUBLIC_ANALYTICS_ENABLED === "true";
+
+export const ANALYTICS_PROVIDER =
+  process.env.NEXT_PUBLIC_ANALYTICS_PROVIDER ?? "posthog";
+
+export const ANALYTICS_ENDPOINT =
+  process.env.NEXT_PUBLIC_ANALYTICS_ENDPOINT ?? "";
+
+function parseSampleRate(raw: string | undefined): number {
+  const parsed = Number(raw);
+  if (!Number.isFinite(parsed)) return 1;
+  return Math.min(1, Math.max(0, parsed));
+}
+
+export const ANALYTICS_SAMPLE_RATE = parseSampleRate(
+  process.env.NEXT_PUBLIC_ANALYTICS_SAMPLE_RATE,
+);
+
+export const analyticsConfig = {
+  enabled: ANALYTICS_ENABLED,
+  provider: ANALYTICS_PROVIDER,
+  endpoint: ANALYTICS_ENDPOINT,
+  sampleRate: ANALYTICS_SAMPLE_RATE,
+} as const;
+
+/**
+ * Backup / disaster-recovery configuration.
+ *
+ * Env vars:
+ *   NEXT_PUBLIC_BACKUP_BUCKET          - object storage bucket for backups
+ *   NEXT_PUBLIC_BACKUP_GEO_REGION      - geo-replica region for redundancy
+ *   NEXT_PUBLIC_BACKUP_INTERVAL_MINUTES - backup schedule interval in minutes
+ *   NEXT_PUBLIC_BACKUP_ALERT_WEBHOOK   - webhook URL alerted on backup failure
+ */
+export const BACKUP_BUCKET = process.env.NEXT_PUBLIC_BACKUP_BUCKET ?? "";
+
+export const BACKUP_GEO_REGION =
+  process.env.NEXT_PUBLIC_BACKUP_GEO_REGION ?? "";
+
+function parseIntervalMinutes(raw: string | undefined): number {
+  const parsed = Number(raw);
+  if (!Number.isFinite(parsed) || parsed <= 0) return 60;
+  return Math.floor(parsed);
+}
+
+export const BACKUP_INTERVAL_MINUTES = parseIntervalMinutes(
+  process.env.NEXT_PUBLIC_BACKUP_INTERVAL_MINUTES,
+);
+
+export const BACKUP_ALERT_WEBHOOK =
+  process.env.NEXT_PUBLIC_BACKUP_ALERT_WEBHOOK ?? "";
+
+export const backupConfig = {
+  bucket: BACKUP_BUCKET,
+  geoRegion: BACKUP_GEO_REGION,
+  intervalMinutes: BACKUP_INTERVAL_MINUTES,
+  alertWebhook: BACKUP_ALERT_WEBHOOK,
+} as const;
+
 export const config = {
   network: STELLAR_NETWORK,
   rpcUrl: RPC_URL,
   contractId,
+  analytics: analyticsConfig,
+  backup: backupConfig,
 } as const;
 
-export default config;
+export default config;
\ No newline at end of file
diff --git a/src/lib/csvExport.ts b/src/lib/csvExport.ts
index 2222445d..a9f926fe 100644
--- a/src/lib/csvExport.ts
+++ b/src/lib/csvExport.ts
@@ -152,6 +152,110 @@ export function filterPaymentsByDateRange(
   });
 }
 
+export interface AgingReportRow {
+  bucket: string;
+  invoice_count: number;
+  total_amount: string;
+  overdue_amount: string;
+  overdue_rate: string;
+}
+
+export interface AgingTrendRow {
+  period: string;
+  bucket: string;
+  invoice_count: number;
+  total_amount: string;
+  overdue_amount: string;
+}
+
+export const AGING_REPORT_COLUMNS = [
+  "bucket",
+  "invoice_count",
+  "total_amount",
+  "overdue_amount",
+  "overdue_rate",
+] as const;
+
+export type AgingReportColumn = (typeof AGING_REPORT_COLUMNS)[number];
+
+export const AGING_REPORT_COLUMN_LABELS: Record<AgingReportColumn, string> = {
+  bucket: "Aging Bucket",
+  invoice_count: "Invoice Count",
+  total_amount: "Total Amount (USDC)",
+  overdue_amount: "Overdue Amount (USDC)",
+  overdue_rate: "Overdue Rate",
+};
+
+export const AGING_TREND_COLUMNS = [
+  "period",
+  "bucket",
+  "invoice_count",
+  "total_amount",
+  "overdue_amount",
+] as const;
+
+export type AgingTrendColumn = (typeof AGING_TREND_COLUMNS)[number];
+
+export const AGING_TREND_COLUMN_LABELS: Record<AgingTrendColumn, string> = {
+  period: "Period",
+  bucket: "Aging Bucket",
+  invoice_count: "Invoice Count",
+  total_amount: "Total Amount (USDC)",
+  overdue_amount: "Overdue Amount (USDC)",
+};
+
+/**
+ * Convert aging bucket rows to CSV string
+ */
+export function agingReportToCSV(
+  rows: AgingReportRow[],
+  columns: readonly AgingReportColumn[] = AGING_REPORT_COLUMNS
+): string {
+  const activeColumns = columns.length > 0 ? columns : AGING_REPORT_COLUMNS;
+  const lines = [activeColumns.join(",")];
+
+  for (const row of rows) {
+    lines.push(
+      activeColumns
+        .map((column) => escapeCSVField(String(row[column] ?? "")))
+        .join(",")
+    );
+  }
+
+  return lines.join("\n");
+}
+
+/**
+ * Convert aging trend rows to CSV string
+ */
+export function agingTrendToCSV(
+  rows: AgingTrendRow[],
+  columns: readonly AgingTrendColumn[] = AGING_TREND_COLUMNS
+): string {
+  const activeColumns = columns.length > 0 ? columns : AGING_TREND_COLUMNS;
+  const lines = [activeColumns.join(",")];
+
+  for (const row of rows) {
+    lines.push(
+      activeColumns
+        .map((column) => escapeCSVField(String(row[column] ?? "")))
+        .join(",")
+    );
+  }
+
+  return lines.join("\n");
+}
+
+/**
+ * Generate filename for aging report export
+ */
+export function generateAgingReportFilename(
+  reportType: "aging" | "trend" = "aging"
+): string {
+  const date = new Date().toISOString().split("T")[0]; // YYYY-MM-DD
+  return `invoice-${reportType}-report-${date}.csv`;
+}
+
 export interface CsvRow {
   [key: string]: string | number;
 }
diff --git a/src/lib/db/schema.ts b/src/lib/db/schema.ts
index d7a913f2..2086d780 100644
--- a/src/lib/db/schema.ts
+++ b/src/lib/db/schema.ts
@@ -7,8 +7,10 @@ import type { DBSchema } from "idb";
 import type { Invoice } from "@stellar-split/sdk";
 
 export const DB_NAME = "stellarsplit-invoice-cache";
-export const DB_VERSION = 1;
+export const DB_VERSION = 2;
 export const INVOICES_STORE = "invoices";
+export const INVOICE_VERSIONS_STORE = "invoiceVersions";
+export const AMENDMENTS_STORE = "amendments";
 
 /** A cached invoice, tagged with the owner it was fetched for and when it landed in the cache. */
 export interface CachedInvoice {
@@ -19,6 +21,46 @@ export interface CachedInvoice {
   invoice: Invoice;
 }
 
+/** A single field-level change captured between two invoice versions. */
+export interface InvoiceVersionDiffEntry {
+  field: string;
+  before: unknown;
+  after: unknown;
+}
+
+/** A stored snapshot of an invoice at a point in time, with the diff from its predecessor. */
+export interface InvoiceVersion {
+  /** Unique version id (e.g. `${invoiceId}:${versionNumber}`). */
+  id: string;
+  invoiceId: string;
+  versionNumber: number;
+  createdAt: number;
+  /** Address of the party that produced this version. */
+  createdBy: string;
+  /** Full invoice snapshot at this version. */
+  invoice: Invoice;
+  /** Field-level diff against the previous version (empty for the initial version). */
+  diff: InvoiceVersionDiffEntry[];
+  /** Optional reference to the amendment that produced this version. */
+  amendmentId?: string;
+}
+
+/** An amendment record capturing the reason and comments for a change. */
+export interface InvoiceAmendment {
+  /** Unique amendment id. */
+  id: string;
+  invoiceId: string;
+  /** Version id this amendment produced. */
+  versionId: string;
+  /** Version id this amendment was applied on top of. */
+  previousVersionId?: string;
+  reason: string;
+  comment?: string;
+  /** Address of the party that made the amendment. */
+  amendedBy: string;
+  createdAt: number;
+}
+
 export interface InvoiceCacheDBSchema extends DBSchema {
   [INVOICES_STORE]: {
     key: string;
@@ -28,4 +70,20 @@ export interface InvoiceCacheDBSchema extends DBSchema {
       "by-owner": string;
     };
   };
-}
+  [INVOICE_VERSIONS_STORE]: {
+    key: string;
+    value: InvoiceVersion;
+    indexes: {
+      "by-invoice": string;
+      "by-timestamp": number;
+    };
+  };
+  [AMENDMENTS_STORE]: {
+    key: string;
+    value: InvoiceAmendment;
+    indexes: {
+      "by-invoice": string;
+      "by-timestamp": number;
+    };
+  };
+}
\ No newline at end of file
diff --git a/src/lib/invoiceAging.ts b/src/lib/invoiceAging.ts
new file mode 100644
index 00000000..bff4e576
--- /dev/null
+++ b/src/lib/invoiceAging.ts
@@ -0,0 +1,391 @@
+/**
+ * Invoice Aging Analytics Library
+ *
+ * Pure, unit-testable functions for computing invoice aging buckets,
+ * overdue rates, collection efficiency, trend series, and threshold-based alerts.
+ */
+
+export type InvoiceStatus = 'paid' | 'unpaid' | 'partial' | 'cancelled' | 'draft';
+
+export interface Invoice {
+  id: string;
+  /** ISO date string of the invoice issue date */
+  issueDate: string;
+  /** ISO date string of the payment deadline / due date */
+  dueDate: string;
+  /** Total amount due on the invoice */
+  amount: number;
+  /** Amount already paid (defaults to 0 if omitted) */
+  amountPaid?: number;
+  status: InvoiceStatus;
+  /** ISO date string of when the invoice was fully paid, if applicable */
+  paidDate?: string;
+}
+
+export type AgingBucketKey =
+  | 'current'
+  | 'days1to30'
+  | 'days31to60'
+  | 'days61to90'
+  | 'days90plus';
+
+export interface AgingBucket {
+  key: AgingBucketKey;
+  label: string;
+  /** Inclusive lower bound in days overdue (0 for current) */
+  minDays: number;
+  /** Inclusive upper bound in days overdue (Infinity for 90+) */
+  maxDays: number;
+  /** Total outstanding amount in this bucket */
+  amount: number;
+  /** Number of invoices in this bucket */
+  count: number;
+  /** Invoice ids in this bucket */
+  invoiceIds: string[];
+}
+
+export interface AgingReport {
+  /** Reference date used for the calculation (ISO string) */
+  asOf: string;
+  buckets: AgingBucket[];
+  /** Total outstanding amount across all buckets */
+  totalOutstanding: number;
+  /** Total number of outstanding invoices */
+  totalInvoices: number;
+  /** Overdue amount (everything past the current bucket) */
+  overdueAmount: number;
+  /** Overdue rate: overdueAmount / totalOutstanding (0 when no outstanding) */
+  overdueRate: number;
+  /** Collection efficiency: paid amount / total invoiced amount (0..1) */
+  collectionEfficiency: number;
+  /** Total amount invoiced (paid + outstanding) */
+  totalInvoiced: number;
+  /** Total amount collected */
+  totalCollected: number;
+}
+
+export interface TrendPoint {
+  /** ISO date string for the point */
+  date: string;
+  totalOutstanding: number;
+  overdueAmount: number;
+  overdueRate: number;
+  collectionEfficiency: number;
+}
+
+export interface AgingAlertThresholds {
+  /** Days overdue at which an invoice is considered aging (default 30) */
+  warningDays?: number;
+  /** Days overdue at which an invoice is considered critical (default 60) */
+  criticalDays?: number;
+  /** Overdue rate (0..1) that triggers a portfolio-level alert (default 0.25) */
+  overdueRateThreshold?: number;
+}
+
+export interface AgingAlert {
+  type: 'invoice' | 'portfolio';
+  severity: 'warning' | 'critical';
+  invoiceId?: string;
+  daysOverdue?: number;
+  amount?: number;
+  overdueRate?: number;
+  message: string;
+}
+
+const MS_PER_DAY = 24 * 60 * 60 * 1000;
+
+export const AGING_BUCKETS: ReadonlyArray<{
+  key: AgingBucketKey;
+  label: string;
+  minDays: number;
+  maxDays: number;
+}> = [
+  { key: 'current', label: 'Current', minDays: 0, maxDays: 0 },
+  { key: 'days1to30', label: '1-30 days', minDays: 1, maxDays: 30 },
+  { key: 'days31to60', label: '31-60 days', minDays: 31, maxDays: 60 },
+  { key: 'days61to90', label: '61-90 days', minDays: 61, maxDays: 90 },
+  { key: 'days90plus', label: '90+ days', minDays: 91, maxDays: Infinity },
+];
+
+function toDate(value: string | Date): Date {
+  return value instanceof Date ? value : new Date(value);
+}
+
+function startOfDay(date: Date): Date {
+  const d = new Date(date.getTime());
+  d.setUTCHours(0, 0, 0, 0);
+  return d;
+}
+
+/**
+ * Number of whole days an invoice is overdue relative to `asOf`.
+ * Returns 0 when not yet due. Negative values are clamped to 0.
+ */
+export function daysOverdue(invoice: Invoice, asOf: string | Date): number {
+  const due = startOfDay(toDate(invoice.dueDate));
+  const ref = startOfDay(toDate(asOf));
+  const diff = Math.floor((ref.getTime() - due.getTime()) / MS_PER_DAY);
+  return diff > 0 ? diff : 0;
+}
+
+/**
+ * Outstanding amount on an invoice (amount minus amount paid), never negative.
+ */
+export function outstandingAmount(invoice: Invoice): number {
+  const paid = invoice.amountPaid ?? 0;
+  const outstanding = invoice.amount - paid;
+  return outstanding > 0 ? outstanding : 0;
+}
+
+/**
+ * Whether an invoice should be considered in aging calculations.
+ * Paid, cancelled, and draft invoices are excluded.
+ */
+export function isAgingEligible(invoice: Invoice): boolean {
+  if (invoice.status === 'paid' || invoice.status === 'cancelled' || invoice.status === 'draft') {
+    return false;
+  }
+  return outstandingAmount(invoice) > 0;
+}
+
+/**
+ * Determine the aging bucket key for a given number of days overdue.
+ */
+export function bucketKeyForDays(days: number): AgingBucketKey {
+  if (days <= 0) return 'current';
+  if (days <= 30) return 'days1to30';
+  if (days <= 60) return 'days31to60';
+  if (days <= 90) return 'days61to90';
+  return 'days90plus';
+}
+
+/**
+ * Compute aging buckets for a set of invoices as of a reference date.
+ */
+export function computeAgingBuckets(
+  invoices: Invoice[],
+  asOf: string | Date,
+): AgingBucket[] {
+  const buckets: AgingBucket[] = AGING_BUCKETS.map((b) => ({
+    key: b.key,
+    label: b.label,
+    minDays: b.minDays,
+    maxDays: b.maxDays,
+    amount: 0,
+    count: 0,
+    invoiceIds: [],
+  }));
+
+  const byKey = new Map<AgingBucketKey, AgingBucket>();
+  for (const bucket of buckets) byKey.set(bucket.key, bucket);
+
+  for (const invoice of invoices) {
+    if (!isAgingEligible(invoice)) continue;
+    const days = daysOverdue(invoice, asOf);
+    const key = bucketKeyForDays(days);
+    const bucket = byKey.get(key);
+    if (!bucket) continue;
+    bucket.amount += outstandingAmount(invoice);
+    bucket.count += 1;
+    bucket.invoiceIds.push(invoice.id);
+  }
+
+  return buckets;
+}
+
+/**
+ * Compute the full aging report for a set of invoices.
+ */
+export function generateAgingReport(
+  invoices: Invoice[],
+  asOf: string | Date,
+): AgingReport {
+  const asOfDate = toDate(asOf);
+  const buckets = computeAgingBuckets(invoices, asOfDate);
+
+  let totalOutstanding = 0;
+  let overdueAmount = 0;
+  let totalInvoices = 0;
+  for (const bucket of buckets) {
+    totalOutstanding += bucket.amount;
+    totalInvoices += bucket.count;
+    if (bucket.key !== 'current') {
+      overdueAmount += bucket.amount;
+    }
+  }
+
+  let totalInvoiced = 0;
+  let totalCollected = 0;
+  for (const invoice of invoices) {
+    if (invoice.status === 'cancelled' || invoice.status === 'draft') continue;
+    totalInvoiced += invoice.amount;
+    totalCollected += Math.min(invoice.amountPaid ?? 0, invoice.amount);
+  }
+
+  const overdueRate = totalOutstanding > 0 ? overdueAmount / totalOutstanding : 0;
+  const collectionEfficiency = totalInvoiced > 0 ? totalCollected / totalInvoiced : 0;
+
+  return {
+    asOf: asOfDate.toISOString(),
+    buckets,
+    totalOutstanding,
+    totalInvoices,
+    overdueAmount,
+    overdueRate,
+    collectionEfficiency,
+    totalInvoiced,
+    totalCollected,
+  };
+}
+
+/**
+ * Produce a trend series of aging metrics over time.
+ *
+ * @param invoices invoices to analyze
+ * @param startDate ISO date for the first point
+ * @param endDate ISO date for the last point
+ * @param intervalDays number of days between points (default 7)
+ */
+export function computeAgingTrend(
+  invoices: Invoice[],
+  startDate: string | Date,
+  endDate: string | Date,
+  intervalDays = 7,
+): TrendPoint[] {
+  const start = startOfDay(toDate(startDate));
+  const end = startOfDay(toDate(endDate));
+  const step = Math.max(1, Math.floor(intervalDays));
+  const points: TrendPoint[] = [];
+
+  if (start.getTime() > end.getTime()) return points;
+
+  for (let t = start.getTime(); t <= end.getTime(); t += step * MS_PER_DAY) {
+    const date = new Date(t);
+    const report = generateAgingReport(invoices, date);
+    points.push({
+      date: date.toISOString(),
+      totalOutstanding: report.totalOutstanding,
+      overdueAmount: report.overdueAmount,
+      overdueRate: report.overdueRate,
+      collectionEfficiency: report.collectionEfficiency,
+    });
+  }
+
+  return points;
+}
+
+/**
+ * Evaluate threshold-based aging alerts.
+ *
+ * Returns per-invoice alerts for invoices that crossed the warning or critical
+ * aging thresholds, plus a portfolio-level alert when the overdue rate exceeds
+ * the configured threshold.
+ */
+export function evaluateAgingAlerts(
+  invoices: Invoice[],
+  asOf: string | Date,
+  thresholds: AgingAlertThresholds = {},
+): AgingAlert[] {
+  const warningDays = thresholds.warningDays ?? 30;
+  const criticalDays = thresholds.criticalDays ?? 60;
+  const overdueRateThreshold = thresholds.overdueRateThreshold ?? 0.25;
+
+  const alerts: AgingAlert[] = [];
+
+  for (const invoice of invoices) {
+    if (!isAgingEligible(invoice)) continue;
+    const days = daysOverdue(invoice, asOf);
+    if (days >= criticalDays) {
+      alerts.push({
+        type: 'invoice',
+        severity: 'critical',
+        invoiceId: invoice.id,
+        daysOverdue: days,
+        amount: outstandingAmount(invoice),
+        message: `Invoice ${invoice.id} is ${days} days overdue (critical threshold ${criticalDays}).`,
+      });
+    } else if (days >= warningDays) {
+      alerts.push({
+        type: 'invoice',
+        severity: 'warning',
+        invoiceId: invoice.id,
+        daysOverdue: days,
+        amount: outstandingAmount(invoice),
+        message: `Invoice ${invoice.id} is ${days} days overdue (warning threshold ${warningDays}).`,
+      });
+    }
+  }
+
+  const report = generateAgingReport(invoices, asOf);
+  if (report.overdueRate > overdueRateThreshold) {
+    alerts.push({
+      type: 'portfolio',
+      severity: report.overdueRate >= overdueRateThreshold * 2 ? 'critical' : 'warning',
+      overdueRate: report.overdueRate,
+      amount: report.overdueAmount,
+      message: `Portfolio overdue rate ${(report.overdueRate * 100).toFixed(1)}% exceeds threshold ${(overdueRateThreshold * 100).toFixed(1)}%.`,
+    });
+  }
+
+  return alerts;
+}
+
+/**
+ * Serialize an aging report to CSV for export.
+ */
+export function agingReportToCsv(report: AgingReport): string {
+  const lines: string[] = [];
+  lines.push('Bucket,Min Days,Max Days,Amount,Count,Invoice IDs');
+  for (const bucket of report.buckets) {
+    const max = bucket.maxDays === Infinity ? '' : String(bucket.maxDays);
+    const ids = bucket.invoiceIds.join('|');
+    lines.push(
+      [
+        escapeCsv(bucket.label),
+        String(bucket.minDays),
+        max,
+        bucket.amount.toFixed(2),
+        String(bucket.count),
+        escapeCsv(ids),
+      ].join(','),
+    );
+  }
+  lines.push('');
+  lines.push('Metric,Value');
+  lines.push(`As Of,${escapeCsv(report.asOf)}`);
+  lines.push(`Total Outstanding,${report.totalOutstanding.toFixed(2)}`);
+  lines.push(`Total Invoices,${report.totalInvoices}`);
+  lines.push(`Overdue Amount,${report.overdueAmount.toFixed(2)}`);
+  lines.push(`Overdue Rate,${(report.overdueRate * 100).toFixed(2)}%`);
+  lines.push(`Collection Efficiency,${(report.collectionEfficiency * 100).toFixed(2)}%`);
+  lines.push(`Total Invoiced,${report.totalInvoiced.toFixed(2)}`);
+  lines.push(`Total Collected,${report.totalCollected.toFixed(2)}`);
+  return lines.join('\n');
+}
+
+/**
+ * Serialize a trend series to CSV for export.
+ */
+export function agingTrendToCsv(points: TrendPoint[]): string {
+  const lines: string[] = [];
+  lines.push('Date,Total Outstanding,Overdue Amount,Overdue Rate,Collection Efficiency');
+  for (const p of points) {
+    lines.push(
+      [
+        escapeCsv(p.date),
+        p.totalOutstanding.toFixed(2),
+        p.overdueAmount.toFixed(2),
+        (p.overdueRate * 100).toFixed(2),
+        (p.collectionEfficiency * 100).toFixed(2),
+      ].join(','),
+    );
+  }
+  return lines.join('\n');
+}
+
+function escapeCsv(value: string): string {
+  if (value.includes(',') || value.includes('"') || value.includes('\n')) {
+    return `"${value.replace(/"/g, '""')}"`;
+  }
+  return value;
+}
\ No newline at end of file
diff --git a/src/lib/invoiceExcelExport.ts b/src/lib/invoiceExcelExport.ts
index c396d482..7b207a9d 100644
--- a/src/lib/invoiceExcelExport.ts
+++ b/src/lib/invoiceExcelExport.ts
@@ -42,6 +42,203 @@ export interface TransactionExportRow {
   status: string;
 }
 
+export interface AgingBucketExportRow {
+  bucket: string;
+  invoiceCount: number;
+  outstandingAmount: string;
+  overdueAmount: string;
+  overdueRate: string;
+  collectionEfficiency: string;
+}
+
+export interface AgingTrendExportRow {
+  period: string;
+  invoiceCount: number;
+  outstandingAmount: string;
+  overdueAmount: string;
+  overdueRate: string;
+  collectionEfficiency: string;
+}
+
+export interface AgingReportExport {
+  buckets: AgingBucketExportRow[];
+  trends: AgingTrendExportRow[];
+}
+
+/** Aging bucket definitions, ordered from current to most overdue. */
+export const AGING_BUCKETS: Array<{ label: string; minDays: number; maxDays: number }> = [
+  { label: 'Current', minDays: -Infinity, maxDays: 0 },
+  { label: '1-30 days', minDays: 1, maxDays: 30 },
+  { label: '31-60 days', minDays: 31, maxDays: 60 },
+  { label: '61-90 days', minDays: 61, maxDays: 90 },
+  { label: '90+ days', minDays: 91, maxDays: Infinity },
+];
+
+const DAY_SECONDS = 86400;
+
+function invoiceTotal(invoice: Invoice): bigint {
+  return invoice.recipients.reduce((sum, r) => sum + r.amount, 0n);
+}
+
+function invoiceOutstanding(invoice: Invoice): bigint {
+  const outstanding = invoiceTotal(invoice) - invoice.funded;
+  return outstanding > 0n ? outstanding : 0n;
+}
+
+function daysOverdue(invoice: Invoice, nowSeconds: number): number {
+  if (!invoice.deadline || invoice.deadline <= 0) return 0;
+  return Math.floor((nowSeconds - invoice.deadline) / DAY_SECONDS);
+}
+
+function bucketForDays(days: number): string {
+  for (const bucket of AGING_BUCKETS) {
+    if (days >= bucket.minDays && days <= bucket.maxDays) return bucket.label;
+  }
+  return AGING_BUCKETS[AGING_BUCKETS.length - 1].label;
+}
+
+function formatRate(numerator: bigint, denominator: bigint): string {
+  if (denominator <= 0n) return '0.00%';
+  const scaled = (numerator * 10000n) / denominator;
+  return `${(Number(scaled) / 100).toFixed(2)}%`;
+}
+
+/**
+ * Build aging bucket and trend rows for the aging report worksheet.
+ * Uses the same filter options as the invoice export so the aging report
+ * reflects exactly the invoices being exported.
+ */
+export function buildAgingReport(
+  invoices: Invoice[],
+  options: ExportFilterOptions = {},
+  nowSeconds: number = Math.floor(Date.now() / 1000)
+): AgingReportExport {
+  const filtered = filterInvoices(invoices, options);
+
+  const bucketTotals = new Map<
+    string,
+    { count: number; outstanding: bigint; overdue: bigint; collected: bigint; total: bigint }
+  >();
+  for (const bucket of AGING_BUCKETS) {
+    bucketTotals.set(bucket.label, {
+      count: 0,
+      outstanding: 0n,
+      overdue: 0n,
+      collected: 0n,
+      total: 0n,
+    });
+  }
+
+  const trendTotals = new Map<
+    string,
+    { count: number; outstanding: bigint; overdue: bigint; collected: bigint; total: bigint }
+  >();
+
+  for (const invoice of filtered) {
+    const total = invoiceTotal(invoice);
+    const outstanding = invoiceOutstanding(invoice);
+    const days = daysOverdue(invoice, nowSeconds);
+    const isOverdue = days > 0 && outstanding > 0n;
+    const overdue = isOverdue ? outstanding : 0n;
+    const collected = invoice.funded > 0n ? invoice.funded : 0n;
+
+    const bucketLabel = bucketForDays(days);
+    const bucket = bucketTotals.get(bucketLabel)!;
+    bucket.count += 1;
+    bucket.outstanding += outstanding;
+    bucket.overdue += overdue;
+    bucket.collected += collected;
+    bucket.total += total;
+
+    const period = new Date(
+      (invoice.deadline > 0 ? invoice.deadline : nowSeconds) * 1000
+    ).toISOString().slice(0, 7);
+    const trend = trendTotals.get(period) ?? {
+      count: 0,
+      outstanding: 0n,
+      overdue: 0n,
+      collected: 0n,
+      total: 0n,
+    };
+    trend.count += 1;
+    trend.outstanding += outstanding;
+    trend.overdue += overdue;
+    trend.collected += collected;
+    trend.total += total;
+    trendTotals.set(period, trend);
+  }
+
+  const buckets: AgingBucketExportRow[] = AGING_BUCKETS.map((bucket) => {
+    const totals = bucketTotals.get(bucket.label)!;
+    return {
+      bucket: bucket.label,
+      invoiceCount: totals.count,
+      outstandingAmount: formatAmount(totals.outstanding),
+      overdueAmount: formatAmount(totals.overdue),
+      overdueRate: formatRate(totals.overdue, totals.outstanding),
+      collectionEfficiency: formatRate(totals.collected, totals.total),
+    };
+  });
+
+  const trends: AgingTrendExportRow[] = Array.from(trendTotals.entries())
+    .sort(([a], [b]) => a.localeCompare(b))
+    .map(([period, totals]) => ({
+      period,
+      invoiceCount: totals.count,
+      outstandingAmount: formatAmount(totals.outstanding),
+      overdueAmount: formatAmount(totals.overdue),
+      overdueRate: formatRate(totals.overdue, totals.outstanding),
+      collectionEfficiency: formatRate(totals.collected, totals.total),
+    }));
+
+  return { buckets, trends };
+}
+
+/**
+ * Build the aging worksheet definition (bucket summary + trend rows)
+ * for inclusion in the generated Excel workbook.
+ */
+export function buildAgingWorksheet(
+  invoices: Invoice[],
+  options: ExportFilterOptions = {},
+  nowSeconds: number = Math.floor(Date.now() / 1000)
+): { name: string; headers: string[]; rows: Record<string, string | number>[] } {
+  const report = buildAgingReport(invoices, options, nowSeconds);
+
+  const headers = [
+    'Section',
+    'Period / Bucket',
+    'Invoice Count',
+    'Outstanding Amount',
+    'Overdue Amount',
+    'Overdue Rate',
+    'Collection Efficiency',
+  ];
+
+  const rows: Record<string, string | number>[] = [
+    ...report.buckets.map((bucket) => ({
+      Section: 'Aging Bucket',
+      'Period / Bucket': bucket.bucket,
+      'Invoice Count': bucket.invoiceCount,
+      'Outstanding Amount': bucket.outstandingAmount,
+      'Overdue Amount': bucket.overdueAmount,
+      'Overdue Rate': bucket.overdueRate,
+      'Collection Efficiency': bucket.collectionEfficiency,
+    })),
+    ...report.trends.map((trend) => ({
+      Section: 'Trend',
+      'Period / Bucket': trend.period,
+      'Invoice Count': trend.invoiceCount,
+      'Outstanding Amount': trend.outstandingAmount,
+      'Overdue Amount': trend.overdueAmount,
+      'Overdue Rate': trend.overdueRate,
+      'Collection Efficiency': trend.collectionEfficiency,
+    })),
+  ];
+
+  return { name: 'Aging Report', headers, rows };
+}
+
 /**
  * Convert invoices to export rows
  */
@@ -275,3 +472,48 @@ export function generateExportFilename(prefix = 'invoices'): string {
   const date = new Date().toISOString().split('T')[0];
   return `${prefix}-${date}.xlsx`;
 }
+
+/**
+ * Generate Excel binary data including the aging report worksheet.
+ * Reuses the existing filter options so the aging sheet matches the
+ * invoices, line items and transactions being exported.
+ */
+export async function generateExcelBinaryWithAging(
+  invoices: Invoice[],
+  options: ExportFilterOptions = {},
+  nowSeconds: number = Math.floor(Date.now() / 1000)
+): Promise<Uint8Array> {
+  const filtered = filterInvoices(invoices, options);
+
+  const sheets = [
+    {
+      name: 'Invoices',
+      headers: [
+        'invoiceId',
+        'status',
+        'creator',
+        'totalAmount',
+        'fundedAmount',
+        'remainingAmount',
+        'recipientCount',
+        'deadline',
+        'createdAt',
+        'token',
+      ],
+      rows: invoicesToExportRows(filtered) as unknown as Record<string, string | number>[],
+    },
+    {
+      name: 'Line Items',
+      headers: ['invoiceId', 'recipientAddress', 'amount', 'status'],
+      rows: lineItemsToExportRows(filtered) as unknown as Record<string, string | number>[],
+    },
+    {
+      name: 'Transactions',
+      headers: ['invoiceId', 'payer', 'amount', 'timestamp', 'txHash', 'status'],
+      rows: transactionsToExportRows(filtered) as unknown as Record<string, string | number>[],
+    },
+    buildAgingWorksheet(filtered, {}, nowSeconds),
+  ];
+
+  return generateExcelBinary(sheets);
+}
diff --git a/src/lib/invoiceVersioning.ts b/src/lib/invoiceVersioning.ts
new file mode 100644
index 00000000..c604b8d5
--- /dev/null
+++ b/src/lib/invoiceVersioning.ts
@@ -0,0 +1,290 @@
+import { randomUUID } from 'crypto';
+
+export type InvoiceStatus = 'draft' | 'pending' | 'approved' | 'rejected' | 'paid' | 'cancelled';
+
+export interface InvoiceRecipient {
+  id: string;
+  name: string;
+  email?: string;
+  amount?: number;
+}
+
+export interface InvoiceSnapshot {
+  id: string;
+  amount: number;
+  currency?: string;
+  recipients: InvoiceRecipient[];
+  deadline?: string | null;
+  notes?: string | null;
+  status: InvoiceStatus;
+}
+
+export type InvoiceField = 'amount' | 'recipients' | 'deadline' | 'notes' | 'status';
+
+export interface FieldDiff<T = unknown> {
+  field: InvoiceField;
+  before: T;
+  after: T;
+}
+
+export interface InvoiceDiff {
+  fields: FieldDiff[];
+  hasChanges: boolean;
+}
+
+export interface AmendmentReason {
+  code: string;
+  label: string;
+}
+
+export interface Amendment {
+  reason: AmendmentReason;
+  comment?: string;
+  amendedBy: string;
+  amendedAt: string;
+}
+
+export interface InvoiceVersion {
+  versionId: string;
+  invoiceId: string;
+  versionNumber: number;
+  snapshot: InvoiceSnapshot;
+  amendment: Amendment;
+  diff: InvoiceDiff;
+  createdAt: string;
+  createdBy: string;
+}
+
+export interface VersionTimelineEntry {
+  versionId: string;
+  versionNumber: number;
+  createdAt: string;
+  createdBy: string;
+  reason: AmendmentReason;
+  comment?: string;
+  changedFields: InvoiceField[];
+  summary: string;
+}
+
+const TRACKED_FIELDS: InvoiceField[] = ['amount', 'recipients', 'deadline', 'notes', 'status'];
+
+function normalizeRecipients(recipients: InvoiceRecipient[] | undefined): InvoiceRecipient[] {
+  if (!recipients) return [];
+  return [...recipients]
+    .map((r) => ({ ...r }))
+    .sort((a, b) => (a.id < b.id ? -1 : a.id > b.id ? 1 : 0));
+}
+
+function recipientsEqual(a: InvoiceRecipient[], b: InvoiceRecipient[]): boolean {
+  const na = normalizeRecipients(a);
+  const nb = normalizeRecipients(b);
+  if (na.length !== nb.length) return false;
+  for (let i = 0; i < na.length; i++) {
+    const ra = na[i];
+    const rb = nb[i];
+    if (
+      ra.id !== rb.id ||
+      ra.name !== rb.name ||
+      (ra.email ?? null) !== (rb.email ?? null) ||
+      (ra.amount ?? null) !== (rb.amount ?? null)
+    ) {
+      return false;
+    }
+  }
+  return true;
+}
+
+function valuesEqual(field: InvoiceField, a: unknown, b: unknown): boolean {
+  if (field === 'recipients') {
+    return recipientsEqual(
+      (a as InvoiceRecipient[]) ?? [],
+      (b as InvoiceRecipient[]) ?? [],
+    );
+  }
+  if (field === 'amount') {
+    return Number(a ?? 0) === Number(b ?? 0);
+  }
+  if (field === 'deadline' || field === 'notes') {
+    return (a ?? null) === (b ?? null);
+  }
+  return a === b;
+}
+
+function cloneSnapshot(snapshot: InvoiceSnapshot): InvoiceSnapshot {
+  return {
+    ...snapshot,
+    recipients: normalizeRecipients(snapshot.recipients),
+  };
+}
+
+/**
+ * Calculate a field-level diff between two invoice snapshots.
+ */
+export function calculateDiff(
+  before: InvoiceSnapshot,
+  after: InvoiceSnapshot,
+): InvoiceDiff {
+  const fields: FieldDiff[] = [];
+  for (const field of TRACKED_FIELDS) {
+    const beforeValue = (before as unknown as Record<string, unknown>)[field];
+    const afterValue = (after as unknown as Record<string, unknown>)[field];
+    if (!valuesEqual(field, beforeValue, afterValue)) {
+      fields.push({
+        field,
+        before: field === 'recipients' ? normalizeRecipients(beforeValue as InvoiceRecipient[]) : beforeValue,
+        after: field === 'recipients' ? normalizeRecipients(afterValue as InvoiceRecipient[]) : afterValue,
+      });
+    }
+  }
+  return { fields, hasChanges: fields.length > 0 };
+}
+
+export interface RecordVersionInput {
+  invoiceId: string;
+  previousSnapshot?: InvoiceSnapshot | null;
+  newSnapshot: InvoiceSnapshot;
+  reason: AmendmentReason;
+  comment?: string;
+  amendedBy: string;
+  amendedAt?: string;
+}
+
+/**
+ * Record a new invoice version, computing the diff against the previous snapshot.
+ * Returns the created version along with the updated history.
+ */
+export function recordVersion(
+  history: InvoiceVersion[],
+  input: RecordVersionInput,
+): { version: InvoiceVersion; history: InvoiceVersion[] } {
+  const existing = history.filter((v) => v.invoiceId === input.invoiceId);
+  const versionNumber = existing.length + 1;
+  const amendedAt = input.amendedAt ?? new Date().toISOString();
+
+  const previousSnapshot = input.previousSnapshot ?? null;
+  const diff = previousSnapshot
+    ? calculateDiff(previousSnapshot, input.newSnapshot)
+    : calculateDiff(
+        {
+          id: input.newSnapshot.id,
+          amount: 0,
+          recipients: [],
+          deadline: null,
+          notes: null,
+          status: 'draft',
+        },
+        input.newSnapshot,
+      );
+
+  const version: InvoiceVersion = {
+    versionId: randomUUID(),
+    invoiceId: input.invoiceId,
+    versionNumber,
+    snapshot: cloneSnapshot(input.newSnapshot),
+    amendment: {
+      reason: input.reason,
+      comment: input.comment,
+      amendedBy: input.amendedBy,
+      amendedAt,
+    },
+    diff,
+    createdAt: amendedAt,
+    createdBy: input.amendedBy,
+  };
+
+  return { version, history: [...history, version] };
+}
+
+/**
+ * Retrieve the version history for a given invoice, ordered by version number.
+ */
+export function getVersionHistory(
+  history: InvoiceVersion[],
+  invoiceId: string,
+): InvoiceVersion[] {
+  return history
+    .filter((v) => v.invoiceId === invoiceId)
+    .sort((a, b) => a.versionNumber - b.versionNumber);
+}
+
+/**
+ * Retrieve a specific version by id.
+ */
+export function getVersionById(
+  history: InvoiceVersion[],
+  versionId: string,
+): InvoiceVersion | undefined {
+  return history.find((v) => v.versionId === versionId);
+}
+
+/**
+ * Retrieve the latest version for an invoice.
+ */
+export function getLatestVersion(
+  history: InvoiceVersion[],
+  invoiceId: string,
+): InvoiceVersion | undefined {
+  const versions = getVersionHistory(history, invoiceId);
+  return versions.length ? versions[versions.length - 1] : undefined;
+}
+
+function buildSummary(version: InvoiceVersion): string {
+  const { fields } = version.diff;
+  if (fields.length === 0) {
+    return `Version ${version.versionNumber} created (no field changes)`;
+  }
+  const names = fields.map((f) => f.field).join(', ');
+  return `Version ${version.versionNumber}: changed ${names}`;
+}
+
+/**
+ * Produce a timeline-friendly list of versions for an invoice.
+ */
+export function getVersionTimeline(
+  history: InvoiceVersion[],
+  invoiceId: string,
+): VersionTimelineEntry[] {
+  return getVersionHistory(history, invoiceId).map((version) => ({
+    versionId: version.versionId,
+    versionNumber: version.versionNumber,
+    createdAt: version.createdAt,
+    createdBy: version.createdBy,
+    reason: version.amendment.reason,
+    comment: version.amendment.comment,
+    changedFields: version.diff.fields.map((f) => f.field),
+    summary: buildSummary(version),
+  }));
+}
+
+export interface AmendmentNotification {
+  invoiceId: string;
+  versionId: string;
+  versionNumber: number;
+  reason: AmendmentReason;
+  comment?: string;
+  amendedBy: string;
+  amendedAt: string;
+  changedFields: InvoiceField[];
+  recipients: InvoiceRecipient[];
+}
+
+/**
+ * Build notifications for parties affected by an amendment.
+ */
+export function buildAmendmentNotifications(
+  version: InvoiceVersion,
+): AmendmentNotification[] {
+  const recipients = version.snapshot.recipients ?? [];
+  if (recipients.length === 0) return [];
+  return recipients.map((recipient) => ({
+    invoiceId: version.invoiceId,
+    versionId: version.versionId,
+    versionNumber: version.versionNumber,
+    reason: version.amendment.reason,
+    comment: version.amendment.comment,
+    amendedBy: version.amendment.amendedBy,
+    amendedAt: version.amendment.amendedAt,
+    changedFields: version.diff.fields.map((f) => f.field),
+    recipients: [recipient],
+  }));
+}
\ No newline at end of file
diff --git a/src/lib/notifications.ts b/src/lib/notifications.ts
index 3244c58f..ac8e0e8b 100644
--- a/src/lib/notifications.ts
+++ b/src/lib/notifications.ts
@@ -7,6 +7,8 @@ interface NotificationPreferences {
   deadlineApproaching: boolean;
   invoiceReleased: boolean;
   invoiceRefunded: boolean;
+  agingAlert: boolean;
+  backupFailure: boolean;
 }
 
 const DEFAULT_PREFS: NotificationPreferences = {
@@ -15,6 +17,8 @@ const DEFAULT_PREFS: NotificationPreferences = {
   deadlineApproaching: true,
   invoiceReleased: true,
   invoiceRefunded: true,
+  agingAlert: true,
+  backupFailure: true,
 };
 
 function getPreferences(): NotificationPreferences {
@@ -130,6 +134,30 @@ export function notifyInvoiceRefunded(invoiceId: string): void {
   });
 }
 
+/** Notify when an invoice crosses an aging threshold (e.g. 30/60/90 days). */
+export function notifyInvoiceAging(
+  invoiceId: string,
+  bucketLabel: string,
+  daysOverdue: number
+): void {
+  const prefs = getPreferences();
+  if (!prefs.agingAlert) return;
+  sendBrowserNotification(`Invoice #${invoiceId} is aging (${bucketLabel})`, {
+    body: `${daysOverdue} day${daysOverdue !== 1 ? 's' : ''} overdue.`,
+    tag: `aging-alert-${invoiceId}-${bucketLabel}`,
+  });
+}
+
+/** Notify when an automated backup run fails. */
+export function notifyBackupFailure(reason: string, runId?: string): void {
+  const prefs = getPreferences();
+  if (!prefs.backupFailure) return;
+  sendBrowserNotification("Automated backup failed", {
+    body: reason,
+    tag: runId ? `backup-failure-${runId}` : "backup-failure",
+  });
+}
+
 /** Stellar address regex: G followed by 55 uppercase alphanumeric chars. */
 const STELLAR_ADDRESS_RE = /\bG[A-Z0-9]{55}\b/g;
 
diff --git a/src/middleware.ts b/src/middleware.ts
index 04e00824..b1fb8383 100644
--- a/src/middleware.ts
+++ b/src/middleware.ts
@@ -1,6 +1,32 @@
 import { NextRequest, NextResponse } from "next/server";
 import { buildCSP, CSP_NONCE_HEADER } from "@/lib/csp";
 
+/**
+ * Reads analytics/backup configuration from environment so that no
+ * third-party domains are hardcoded into the CSP. When analytics is
+ * disabled (the default), the policy stays strict and no extra origins
+ * are allowed.
+ */
+function getAnalyticsOrigins(): string[] {
+  if (process.env.ANALYTICS_ENABLED !== "true") {
+    return [];
+  }
+  return (process.env.ANALYTICS_ENDPOINT_ORIGINS ?? "")
+    .split(",")
+    .map((origin) => origin.trim())
+    .filter(Boolean);
+}
+
+function getBackupWebhookOrigins(): string[] {
+  if (process.env.BACKUP_ALERTS_ENABLED !== "true") {
+    return [];
+  }
+  return (process.env.BACKUP_WEBHOOK_ORIGINS ?? "")
+    .split(",")
+    .map((origin) => origin.trim())
+    .filter(Boolean);
+}
+
 /**
  * Generates a fresh CSP nonce per request and forwards it two ways:
  *  - as a request header, so Server Components can read it via next/headers
@@ -12,7 +38,16 @@ import { buildCSP, CSP_NONCE_HEADER } from "@/lib/csp";
 export function middleware(request: NextRequest) {
   const nonce = Buffer.from(crypto.randomUUID()).toString("base64");
   const isEmbed = request.nextUrl.pathname.startsWith("/embed/");
-  const csp = buildCSP(nonce, { allowFraming: isEmbed });
+
+  const connectSrc = [
+    ...getAnalyticsOrigins(),
+    ...getBackupWebhookOrigins(),
+  ];
+
+  const csp = buildCSP(nonce, {
+    allowFraming: isEmbed,
+    connectSrc: connectSrc.length > 0 ? connectSrc : undefined,
+  });
 
   const requestHeaders = new Headers(request.headers);
   requestHeaders.set(CSP_NONCE_HEADER, nonce);
@@ -35,4 +70,4 @@ export const config = {
      */
     "/((?!_next/static|_next/image|favicon.ico|icons/|manifest.json|sw.js).*)",
   ],
-};
+};
\ No newline at end of file