diff --git a/apps/extension/README.md b/apps/extension/README.md
index 7b7c3aa..3b9b005 100644
--- a/apps/extension/README.md
+++ b/apps/extension/README.md
@@ -14,3 +14,21 @@ Build-time public env (WXT inlines `WXT_PUBLIC_*` into the client bundle):
   - A **dev build** (`wxt dev`) with this unset falls back to `http://localhost:3000` and `http://localhost:5173`.
 - `WXT_PUBLIC_ALLOW_ANY_PAIR_ORIGIN` — set to `1` to explicitly disable the pair-origin restriction (any origin may pair). Named escape hatch only; logs a warning on every startup. **Never set this in a production build.**
 - `WXT_PUBLIC_MAINNET_RPC_URL` — trusted Soroban RPC used to anchor the device signer's signature-expiration ledger on **mainnet** (L4). The extension never trusts the paired wallet's `rpcUrl` for this. Testnet uses SDF's pinned public endpoint automatically; mainnet has no universal public RPC, so this must be set — **mainnet signing fails closed if it is unset** rather than trusting the caller-supplied endpoint.
+
+## Input Sanitization (#312)
+
+dApp-provided connection payloads (such as dApp names, origins, descriptions, and icon URLs) are sanitized before being processed or rendered in the popup UI:
+- **HTML & Script Escaping**: HTML special characters (`<`, `>`, `&`, `"`, `'`, `/`) are escaped using `escapeHtml()`.
+- **Tag Stripping**: All HTML tags (`<script>`, `<iframe>`, etc.) are stripped using `sanitizeString()`.
+- **URL Protocol Filtering**: Dangerous URI schemes (`javascript:`, `data:`, `vbscript:`) are filtered out by `sanitizeUrl()`.
+- **Control Character Scrubbing**: Control characters are stripped to prevent display spoofing.
+- **Length Truncation**: Strings are bounded by maximum length ceilings (e.g. 100 chars for names, 500 chars for descriptions).
+
+## Error Reporting Integration (#302)
+
+Uncaught exceptions, background worker rejections, and signing failures are automatically captured and forwarded to the centralized error reporting client via `backgroundErrorReporter`:
+- **Context Metadata**: Every reported error automatically embeds `extensionVersion` (from `WXT_PUBLIC_VERSION`) and `browserInfo` (`navigator.userAgent` or worker environment tag).
+- **Global Handlers**: Registered on background worker startup (`self.addEventListener('error')`, `self.addEventListener('unhandledrejection')`).
+- **Resilience**: Error delivery failures fail safely to console without interrupting service worker routing or user transaction flows.
+
+
diff --git a/apps/extension/entrypoints/background.ts b/apps/extension/entrypoints/background.ts
index 9c19f37..7647890 100644
--- a/apps/extension/entrypoints/background.ts
+++ b/apps/extension/entrypoints/background.ts
@@ -21,6 +21,7 @@ import {
   type PairOriginPolicy,
 } from "../lib/pair-origins";
 import { addGrant, loadState, revokeGrant, setPairedWallet } from "../lib/state";
+import { backgroundErrorReporter } from "../lib/error-reporter";
 
 // Background service worker (technical-doc.md §6.2B, §7.3): routes validated
 // dApp requests, holds the pending-approval queue, and opens the approval
@@ -35,6 +36,20 @@ export default defineBackground(() => {
   // Track the open approval window so we don't spawn a new one per request.
   let approvalWindowId: number | undefined;
 
+  // Global unhandled error handlers for background worker (#302)
+  if (typeof self !== "undefined") {
+    self.addEventListener("error", (event) => {
+      void backgroundErrorReporter.reportError(event.error ?? event.message, {
+        source: "background_unhandled_error",
+      });
+    });
+    self.addEventListener("unhandledrejection", (event) => {
+      void backgroundErrorReporter.reportError(event.reason, {
+        source: "background_unhandled_rejection",
+      });
+    });
+  }
+
   // L3: resolve the pair-origin allowlist once at startup. A misconfigured
   // production build (no origins, no escape hatch) throws — we DISABLE pairing
   // rather than fall back, so an unconfigured prod artifact can never pair with
@@ -51,8 +66,10 @@ export default defineBackground(() => {
   } catch (err) {
     if (err instanceof PairOriginsMisconfiguredError) {
       console.error(`[vellar] pairing disabled: ${err.message}`);
+      void backgroundErrorReporter.reportError(err, { source: "pair_origins_misconfigured" });
       pairOrigins = []; // fail closed: no origin may pair
     } else {
+      void backgroundErrorReporter.reportError(err, { source: "pair_origins_init" });
       throw err;
     }
   }
@@ -176,6 +193,10 @@ export default defineBackground(() => {
         });
         entry.resolve({ method: "sign_transaction", result: { signedXdr } });
       } catch (err) {
+        void backgroundErrorReporter.reportError(err, {
+          method: "sign_transaction",
+          origin: entry.origin,
+        });
         entry.resolve(
           errorPayload("internal", err instanceof Error ? err.message : "Signing failed"),
         );
diff --git a/apps/extension/entrypoints/popup/App.tsx b/apps/extension/entrypoints/popup/App.tsx
index 9e3eef1..e7ec5d9 100644
--- a/apps/extension/entrypoints/popup/App.tsx
+++ b/apps/extension/entrypoints/popup/App.tsx
@@ -77,21 +77,23 @@ interface RequestDescription {
   address?: string;
 }
 
+import { sanitizeString } from "../../lib/sanitization";
+
 function describeRequest(request: PendingApprovalSummary["request"]): RequestDescription {
   switch (request.method) {
     case "connect":
       return { text: "wants to connect: see your address and request transaction approvals." };
     case "pair":
       return {
-        text: `wants to pair this extension as a device signer on ${request.params.network}. You'll confirm with your passkey next; the pairing expires automatically.`,
-        address: request.params.address,
+        text: `wants to pair this extension as a device signer on ${sanitizeString(request.params.network)}. You'll confirm with your passkey next; the pairing expires automatically.`,
+        address: sanitizeString(request.params.address),
       };
     case "sign_transaction":
       return {
-        text: `wants you to sign a transaction on ${request.params.network}. Approving signs it with this device's key — review the site carefully.`,
+        text: `wants you to sign a transaction on ${sanitizeString(request.params.network)}. Approving signs it with this device's key — review the site carefully.`,
       };
     default:
-      return { text: `sent a ${request.method} request.` };
+      return { text: `sent a ${sanitizeString((request as { method: string }).method)} request.` };
   }
 }
 
diff --git a/apps/extension/lib/error-reporter.test.ts b/apps/extension/lib/error-reporter.test.ts
new file mode 100644
index 0000000..beea6de
--- /dev/null
+++ b/apps/extension/lib/error-reporter.test.ts
@@ -0,0 +1,58 @@
+import { describe, it, expect, vi } from "vitest";
+import {
+  ErrorReporter,
+  DefaultErrorReportClient,
+  type ErrorReportPayload,
+} from "./error-reporter";
+
+describe("extension error reporter integration (#302)", () => {
+  it("includes extension version and browser info in reported errors", async () => {
+    const mockClient = new DefaultErrorReportClient();
+    const reporter = new ErrorReporter({
+      extensionVersion: "1.2.3",
+      browserInfo: "Mozilla/5.0 (Windows NT 10.0; Chrome/120.0)",
+      client: mockClient,
+    });
+
+    const testError = new TypeError("Network request failed");
+    const payload = await reporter.reportError(testError, {
+      route: "provider-request",
+      origin: "https://dapp.example.com",
+    });
+
+    expect(payload.name).toBe("TypeError");
+    expect(payload.message).toBe("Network request failed");
+    expect(payload.context.extensionVersion).toBe("1.2.3");
+    expect(payload.context.browserInfo).toBe("Mozilla/5.0 (Windows NT 10.0; Chrome/120.0)");
+    expect(payload.context.origin).toBe("https://dapp.example.com");
+
+    const reports = mockClient.getReports();
+    expect(reports.length).toBe(1);
+    expect(reports[0]).toEqual(payload);
+  });
+
+  it("handles non-Error objects and string throws gracefully", async () => {
+    const mockClient = new DefaultErrorReportClient();
+    const reporter = new ErrorReporter({ client: mockClient });
+
+    const payload = await reporter.reportError("String error message", {
+      handler: "handlePairApproval",
+    });
+
+    expect(payload.name).toBe("Error");
+    expect(payload.message).toBe("String error message");
+    expect(payload.context.handler).toBe("handlePairApproval");
+  });
+
+  it("catches client delivery errors without crashing the background worker", async () => {
+    const failingClient = {
+      send: vi.fn().mockRejectedValue(new Error("Network offline")),
+    };
+    const reporter = new ErrorReporter({ client: failingClient });
+
+    const payload = await reporter.reportError(new Error("Worker error"));
+
+    expect(failingClient.send).toHaveBeenCalledTimes(1);
+    expect(payload.message).toBe("Worker error");
+  });
+});
diff --git a/apps/extension/lib/error-reporter.ts b/apps/extension/lib/error-reporter.ts
new file mode 100644
index 0000000..4333fbe
--- /dev/null
+++ b/apps/extension/lib/error-reporter.ts
@@ -0,0 +1,92 @@
+/**
+ * Error reporting service integration for the extension background worker (#302).
+ * Captures uncaught and operational errors in the background worker and forwards
+ * them to the centralized reporting endpoint along with extension version and browser metadata.
+ */
+
+export interface ErrorReportContext {
+  extensionVersion: string;
+  browserInfo: string;
+  userAgent?: string;
+  url?: string;
+  [key: string]: unknown;
+}
+
+export interface ErrorReportPayload {
+  message: string;
+  name: string;
+  stack?: string;
+  context: ErrorReportContext;
+  timestamp: string;
+}
+
+export interface ErrorReportClient {
+  send(payload: ErrorReportPayload): Promise<void>;
+}
+
+/** Default in-memory/console error reporting client fallback. */
+export class DefaultErrorReportClient implements ErrorReportClient {
+  private readonly reports: ErrorReportPayload[] = [];
+
+  async send(payload: ErrorReportPayload): Promise<void> {
+    this.reports.push(payload);
+    console.error("[vellar-error-reporter]", payload.name, payload.message, payload.context);
+  }
+
+  getReports(): ErrorReportPayload[] {
+    return [...this.reports];
+  }
+}
+
+export interface ErrorReporterOptions {
+  extensionVersion?: string;
+  browserInfo?: string;
+  client?: ErrorReportClient;
+}
+
+export class ErrorReporter {
+  private readonly extensionVersion: string;
+  private readonly browserInfo: string;
+  private readonly client: ErrorReportClient;
+
+  constructor(options: ErrorReporterOptions = {}) {
+    this.extensionVersion =
+      options.extensionVersion ??
+      (typeof process !== "undefined" && process.env?.WXT_PUBLIC_VERSION
+        ? process.env.WXT_PUBLIC_VERSION
+        : "0.1.0");
+    this.browserInfo =
+      options.browserInfo ??
+      (typeof navigator !== "undefined" ? navigator.userAgent : "BackgroundWorker/VellarExtension");
+    this.client = options.client ?? new DefaultErrorReportClient();
+  }
+
+  async reportError(
+    error: unknown,
+    additionalContext: Record<string, unknown> = {},
+  ): Promise<ErrorReportPayload> {
+    const errObj = error instanceof Error ? error : new Error(String(error ?? "Unknown Error"));
+    const payload: ErrorReportPayload = {
+      name: errObj.name || "Error",
+      message: errObj.message || "An unknown error occurred",
+      stack: errObj.stack,
+      context: {
+        extensionVersion: this.extensionVersion,
+        browserInfo: this.browserInfo,
+        ...additionalContext,
+      },
+      timestamp: new Date().toISOString(),
+    };
+
+    try {
+      await this.client.send(payload);
+    } catch (sendErr) {
+      console.error("Failed to deliver error report payload", sendErr);
+    }
+
+    return payload;
+  }
+}
+
+/** Global background worker error reporter instance */
+export const backgroundErrorReporter = new ErrorReporter();
diff --git a/apps/extension/lib/router.ts b/apps/extension/lib/router.ts
index 7dfcc57..c656585 100644
--- a/apps/extension/lib/router.ts
+++ b/apps/extension/lib/router.ts
@@ -21,6 +21,8 @@ function respond(payload: ResponsePayload, revokeGrant?: boolean): RouteDecision
   return revokeGrant ? { kind: "respond", payload, revokeGrant } : { kind: "respond", payload };
 }
 
+import { sanitizeString } from "./sanitization";
+
 export function routeProviderRequest(
   request: ProviderRequest,
   rawOrigin: string,
@@ -34,6 +36,7 @@ export function routeProviderRequest(
   if (!origin) {
     return respond(errorPayload("invalid_request", "Requests from this origin are not supported"));
   }
+  const cleanOrigin = sanitizeString(origin);
 
   // Pairing is the one method that must work while nothing is paired yet.
   // Always requires explicit popup approval (origin + wallet shown), and the
@@ -47,7 +50,7 @@ export function routeProviderRequest(
         errorPayload("unauthorized", "This origin is not permitted to pair the Vellar extension"),
       );
     }
-    return { kind: "needs-approval", origin };
+    return { kind: "needs-approval", origin: cleanOrigin };
   }
 
   // Status probe: no approval, but only confirms an address+network the
@@ -83,7 +86,7 @@ export function routeProviderRequest(
           result: { address: wallet.address, network: wallet.network },
         });
       }
-      return { kind: "needs-approval", origin };
+      return { kind: "needs-approval", origin: cleanOrigin };
     }
 
     case "get_address": {
@@ -102,7 +105,7 @@ export function routeProviderRequest(
       }
       // Every transaction requires explicit approval — a grant only allows
       // the origin to ASK (§5.3 no silent signing).
-      return { kind: "needs-approval", origin };
+      return { kind: "needs-approval", origin: cleanOrigin };
     }
 
     case "disconnect": {
diff --git a/apps/extension/lib/sanitization.test.ts b/apps/extension/lib/sanitization.test.ts
new file mode 100644
index 0000000..6e9d8cf
--- /dev/null
+++ b/apps/extension/lib/sanitization.test.ts
@@ -0,0 +1,86 @@
+import { describe, it, expect } from "vitest";
+import {
+  escapeHtml,
+  sanitizeUrl,
+  sanitizeString,
+  sanitizeDAppMetadata,
+} from "./sanitization";
+
+describe("input sanitization helpers (#312)", () => {
+  describe("escapeHtml", () => {
+    it("escapes script tags and special HTML characters", () => {
+      expect(escapeHtml("<script>alert('xss')</script>")).toBe(
+        "&lt;script&gt;alert(&#x27;xss&#x27;)&lt;&#x2F;script&gt;",
+      );
+      expect(escapeHtml('Hello "World" & <Friends>')).toBe(
+        "Hello &quot;World&quot; &amp; &lt;Friends&gt;",
+      );
+    });
+  });
+
+  describe("sanitizeUrl", () => {
+    it("blocks javascript: and data: URIs", () => {
+      expect(sanitizeUrl("javascript:alert(1)")).toBe("");
+      expect(sanitizeUrl("JAVASCRIPT:alert(1)")).toBe("");
+      expect(sanitizeUrl("data:text/html,<script>alert(1)</script>")).toBe("");
+      expect(sanitizeUrl("vbscript:msgbox(1)")).toBe("");
+    });
+
+    it("allows valid http and https URLs", () => {
+      expect(sanitizeUrl("https://example.com/icon.png")).toBe(
+        "https:&#x2F;&#x2F;example.com&#x2F;icon.png",
+      );
+    });
+
+    it("handles undefined or null inputs", () => {
+      expect(sanitizeUrl(undefined)).toBe("");
+      expect(sanitizeUrl("")).toBe("");
+    });
+  });
+
+  describe("sanitizeString", () => {
+    it("strips HTML tags and removes control characters", () => {
+      expect(sanitizeString("<img src=x onerror=alert(1)>Malicious")).toBe(
+        "Malicious",
+      );
+      expect(sanitizeString("Clean\x00Name")).toBe("CleanName");
+    });
+
+    it("truncates string to specified max length", () => {
+      const longInput = "a".repeat(200);
+      expect(sanitizeString(longInput, 50).length).toBe(50);
+    });
+
+    it("handles non-string or malformed inputs safely", () => {
+      expect(sanitizeString(12345)).toBe("12345");
+      expect(sanitizeString({ invalid: "object" })).toBe("[object Object]");
+      expect(sanitizeString(null)).toBe("");
+      expect(sanitizeString(undefined)).toBe("");
+    });
+  });
+
+  describe("sanitizeDAppMetadata", () => {
+    it("sanitizes full dApp metadata payload containing script injection attempts", () => {
+      const payload = {
+        name: "<script>eval('bad')</script>DApp Exchange",
+        description: "Best DEX <iframe src='http://evil.com'></iframe> for tokens",
+        iconUrl: "javascript:void(0)",
+        origin: "https://dapp.example.com",
+      };
+
+      const result = sanitizeDAppMetadata(payload);
+
+      expect(result.name).not.toContain("<script>");
+      expect(result.name).toContain("DApp Exchange");
+      expect(result.description).not.toContain("<iframe");
+      expect(result.description).toContain("Best DEX  for tokens");
+      expect(result.iconUrl).toBe("");
+      expect(result.origin).toBe("https:&#x2F;&#x2F;dapp.example.com");
+    });
+
+    it("provides fallback for missing or empty name", () => {
+      const result = sanitizeDAppMetadata({ name: "" });
+      expect(result.name).toBe("Unknown dApp");
+    });
+  });
+});
diff --git a/apps/extension/lib/sanitization.ts b/apps/extension/lib/sanitization.ts
new file mode 100644
index 0000000..b05615a
--- /dev/null
+++ b/apps/extension/lib/sanitization.ts
@@ -0,0 +1,79 @@
+/**
+ * Input sanitization helpers for dApp connection requests and metadata payloads.
+ * Prevents HTML/script injection attacks and normalizes malformed payload fields
+ * before displaying them in the extension UI.
+ */
+
+const MAX_NAME_LENGTH = 100;
+const MAX_DESCRIPTION_LENGTH = 500;
+const MAX_ORIGIN_LENGTH = 200;
+
+/**
+ * Escape HTML special characters to prevent script injection when rendered in the UI.
+ */
+export function escapeHtml(str: string): string {
+  return str
+    .replace(/&/g, "&amp;")
+    .replace(/</g, "&lt;")
+    .replace(/>/g, "&gt;")
+    .replace(/"/g, "&quot;")
+    .replace(/'/g, "&#x27;")
+    .replace(/\//g, "&#x2F;");
+}
+
+/**
+ * Remove dangerous URI schemes like javascript: or data: from URLs.
+ */
+export function sanitizeUrl(url: string | undefined): string {
+  if (!url || typeof url !== "string") return "";
+  const trimmed = url.trim();
+  const lower = trimmed.toLowerCase();
+  if (lower.startsWith("javascript:") || lower.startsWith("data:") || lower.startsWith("vbscript:")) {
+    return "";
+  }
+  return escapeHtml(trimmed);
+}
+
+/**
+ * Sanitize a plain text string field (name, title, description, etc.).
+ * Strips HTML tags, control characters, and enforces length limits.
+ */
+export function sanitizeString(
+  input: unknown,
+  maxLength: number = MAX_DESCRIPTION_LENGTH,
+): string {
+  if (input === null || input === undefined) return "";
+  const str = String(input);
+  // Remove control characters (except space, tab, newline)
+  const cleaned = str.replace(/[\x00-\x08\x0B\x0C\x0E-\x1F\x7F]/g, "");
+  // Strip tags and escape remaining HTML
+  const stripped = cleaned.replace(/<[^>]*>?/gm, "");
+  const escaped = escapeHtml(stripped.trim());
+  return escaped.slice(0, maxLength);
+}
+
+export interface DAppMetadataInput {
+  name?: unknown;
+  description?: unknown;
+  iconUrl?: unknown;
+  origin?: unknown;
+}
+
+export interface SanitizedDAppMetadata {
+  name: string;
+  description: string;
+  iconUrl: string;
+  origin: string;
+}
+
+/**
+ * Sanitize connection request metadata payload from a dApp.
+ */
+export function sanitizeDAppMetadata(payload: DAppMetadataInput): SanitizedDAppMetadata {
+  return {
+    name: sanitizeString(payload.name, MAX_NAME_LENGTH) || "Unknown dApp",
+    description: sanitizeString(payload.description, MAX_DESCRIPTION_LENGTH),
+    iconUrl: sanitizeUrl(typeof payload.iconUrl === "string" ? payload.iconUrl : undefined),
+    origin: sanitizeString(payload.origin, MAX_ORIGIN_LENGTH),
+  };
+}
diff --git a/docs/observability.md b/docs/observability.md
index 814033c..503871c 100644
--- a/docs/observability.md
+++ b/docs/observability.md
@@ -146,6 +146,17 @@ vela_worker_queue_depth{service="worker-service"}
 vela_worker_processing_lag_seconds{service="worker-service"}
 ```
 
+## Distributed Tracing (#301)
+
+End-to-end trace visibility across service boundaries during policy generation and deployment flows is captured using OpenTelemetry-compatible trace spans via `@vellar/service-kit`:
+
+### Trace Propagation Flow
+1. **API Gateway (`api-gateway`)**: Injects or extracts `x-trace-id`, `x-span-id`, and W3C `traceparent` headers on incoming HTTP requests and proxies them to downstream services.
+2. **Policy Service (`policy-service`)**: Extracts trace context from headers and wraps policy generation and deployment operations in `withTraceSpan("policy-service", "policy.deploy-instance", traceCtx)`. Propagates `traceId` with queued verification and deployment jobs.
+3. **Worker Service (`worker-service`)**: Extracts `traceId` from claimed deployment jobs and executes verification in `withTraceSpan("worker-service", "policy.execute", traceCtx)`.
+
+Trace spans are recorded in `TraceCollector` and exportable to OpenTelemetry APM backends (Jaeger, Zipkin, Datadog).
+
 ### Structured events
 
 The following events are emitted via `logEvent()` for operational search and
diff --git a/packages/service-kit/src/index.ts b/packages/service-kit/src/index.ts
index 0a0960f..58509cd 100644
--- a/packages/service-kit/src/index.ts
+++ b/packages/service-kit/src/index.ts
@@ -55,6 +55,16 @@ export {
 
 export { createPgSpendBudget, type BudgetDb, type PgBudgetConfig } from "./pg-budget";
 
+export {
+  extractTraceContext,
+  injectTraceContext,
+  withTraceSpan,
+  TraceCollector,
+  type TraceSpan,
+  type TraceContext,
+  type TraceHeaderMap,
+} from "./tracing";
+
 export {
   createCircuitBreaker,
   circuitBreakerLimitsFromEnv,
diff --git a/packages/service-kit/src/tracing.test.ts b/packages/service-kit/src/tracing.test.ts
new file mode 100644
index 0000000..aa6b490
--- /dev/null
+++ b/packages/service-kit/src/tracing.test.ts
@@ -0,0 +1,82 @@
+import { describe, it, expect, beforeEach } from "vitest";
+import {
+  extractTraceContext,
+  injectTraceContext,
+  withTraceSpan,
+  TraceCollector,
+} from "./tracing";
+
+describe("distributed tracing module (#301)", () => {
+  beforeEach(() => {
+    TraceCollector.getInstance().clear();
+  });
+
+  it("extracts and injects trace headers across service boundaries", () => {
+    const context = extractTraceContext({
+      "x-trace-id": "trace-12345",
+      "x-span-id": "span-67890",
+    });
+
+    expect(context.traceId).toBe("trace-12345");
+    expect(context.spanId).toBe("span-67890");
+
+    const injected = injectTraceContext(context);
+    expect(injected["x-trace-id"]).toBe("trace-12345");
+    expect(injected.traceparent).toContain("trace12345");
+  });
+
+  it("extracts trace context from W3C traceparent header", () => {
+    const context = extractTraceContext({
+      traceparent: "00-4bf92f3577b34da6a3ce929d0e0e4736-00f067aa0ba902b7-01",
+    });
+
+    expect(context.traceId).toBe("4bf92f3577b34da6a3ce929d0e0e4736");
+    expect(context.spanId).toBe("00f067aa0ba902b7");
+  });
+
+  it("records trace spans across multi-service deployment flow", async () => {
+    const traceCtx = extractTraceContext({ "x-trace-id": "deploy-trace-999" });
+
+    // Service 1: API Gateway
+    await withTraceSpan("api-gateway", "proxy.policies.deploy", traceCtx, async (gwSpan) => {
+      // Service 2: Policy Service
+      const policyCtx = { traceId: gwSpan.traceId, spanId: gwSpan.spanId };
+      await withTraceSpan("policy-service", "policy.deploy", policyCtx, async (psSpan) => {
+        // Service 3: Worker Service
+        const workerCtx = { traceId: psSpan.traceId, spanId: psSpan.spanId };
+        await withTraceSpan("worker-service", "policy.execute", workerCtx, async () => {
+          return { status: "deployed" };
+        });
+      });
+    });
+
+    const spans = TraceCollector.getInstance().getSpans("deploy-trace-999");
+    expect(spans.length).toBe(3);
+
+    const services = spans.map((s) => s.service);
+    expect(services).toContain("worker-service");
+    expect(services).toContain("policy-service");
+    expect(services).toContain("api-gateway");
+
+    for (const span of spans) {
+      expect(span.traceId).toBe("deploy-trace-999");
+      expect(span.status).toBe("ok");
+      expect(span.endTimeMs).toBeGreaterThanOrEqual(span.startTimeMs);
+    }
+  });
+
+  it("records error status when span operation throws", async () => {
+    const traceCtx = extractTraceContext();
+
+    await expect(
+      withTraceSpan("policy-service", "failing-span", traceCtx, async () => {
+        throw new Error("Deployment verification failed");
+      }),
+    ).rejects.toThrow("Deployment verification failed");
+
+    const spans = TraceCollector.getInstance().getSpans(traceCtx.traceId);
+    expect(spans.length).toBe(1);
+    expect(spans[0].status).toBe("error");
+    expect(spans[0].attributes.error).toBe("Deployment verification failed");
+  });
+});
diff --git a/packages/service-kit/src/tracing.ts b/packages/service-kit/src/tracing.ts
new file mode 100644
index 0000000..8c33b09
--- /dev/null
+++ b/packages/service-kit/src/tracing.ts
@@ -0,0 +1,139 @@
+/**
+ * Distributed tracing primitives and span context propagation helpers (#301).
+ * Enables end-to-end trace visibility across service boundaries (api-gateway -> policy-service -> worker-service).
+ */
+
+import { randomUUID } from "node:crypto";
+
+export interface TraceSpan {
+  traceId: string;
+  spanId: string;
+  parentSpanId?: string;
+  service: string;
+  name: string;
+  startTimeMs: number;
+  endTimeMs?: number;
+  status: "ok" | "error";
+  attributes: Record<string, unknown>;
+}
+
+export interface TraceContext {
+  traceId: string;
+  spanId?: string;
+}
+
+export interface TraceHeaderMap {
+  [key: string]: string | undefined;
+}
+
+export class TraceCollector {
+  private static instance: TraceCollector;
+  private readonly spans: TraceSpan[] = [];
+
+  public static getInstance(): TraceCollector {
+    if (!TraceCollector.instance) {
+      TraceCollector.instance = new TraceCollector();
+    }
+    return TraceCollector.instance;
+  }
+
+  public recordSpan(span: TraceSpan): void {
+    this.spans.push(span);
+  }
+
+  public getSpans(traceId?: string): TraceSpan[] {
+    if (traceId) {
+      return this.spans.filter((s) => s.traceId === traceId);
+    }
+    return [...this.spans];
+  }
+
+  public clear(): void {
+    this.spans.length = 0;
+  }
+}
+
+/**
+ * Generate or extract a traceId from HTTP headers / metadata.
+ */
+export function extractTraceContext(headers?: TraceHeaderMap): TraceContext {
+  if (!headers) {
+    return { traceId: randomUUID() };
+  }
+
+  const rawTraceId =
+    headers["x-trace-id"] ||
+    headers["X-Trace-Id"] ||
+    headers["x-request-id"] ||
+    headers["X-Request-Id"];
+
+  const rawTraceparent = headers["traceparent"] || headers["Traceparent"];
+
+  if (rawTraceparent && typeof rawTraceparent === "string") {
+    // W3C traceparent format: 00-4bf92f3577b34da6a3ce929d0e0e4736-00f067aa0ba902b7-01
+    const parts = rawTraceparent.split("-");
+    if (parts.length >= 3 && parts[1]) {
+      return { traceId: parts[1], spanId: parts[2] };
+    }
+  }
+
+  if (rawTraceId && typeof rawTraceId === "string") {
+    return { traceId: rawTraceId, spanId: headers["x-span-id"] as string | undefined };
+  }
+
+  return { traceId: randomUUID() };
+}
+
+/**
+ * Inject trace context into outgoing HTTP headers or queue message metadata.
+ */
+export function injectTraceContext(
+  context: TraceContext,
+  headers: Record<string, string> = {},
+): Record<string, string> {
+  const spanId = context.spanId ?? randomUUID().slice(0, 16);
+  return {
+    ...headers,
+    "x-trace-id": context.traceId,
+    "x-span-id": spanId,
+    traceparent: `00-${context.traceId.replace(/-/g, "")}-${spanId.slice(0, 16)}-01`,
+  };
+}
+
+/**
+ * Create and execute a traced span function, automatically recording timing and status.
+ */
+export async function withTraceSpan<T>(
+  service: string,
+  name: string,
+  context: TraceContext,
+  fn: (span: TraceSpan) => Promise<T>,
+  attributes: Record<string, unknown> = {},
+): Promise<T> {
+  const spanId = randomUUID().slice(0, 16);
+  const startTimeMs = Date.now();
+  const span: TraceSpan = {
+    traceId: context.traceId,
+    spanId,
+    parentSpanId: context.spanId,
+    service,
+    name,
+    startTimeMs,
+    status: "ok",
+    attributes: { ...attributes },
+  };
+
+  try {
+    const result = await fn(span);
+    span.endTimeMs = Date.now();
+    span.status = "ok";
+    TraceCollector.getInstance().recordSpan(span);
+    return result;
+  } catch (err) {
+    span.endTimeMs = Date.now();
+    span.status = "error";
+    span.attributes.error = err instanceof Error ? err.message : String(err);
+    TraceCollector.getInstance().recordSpan(span);
+    throw err;
+  }
+}
diff --git a/services/api-gateway/src/server.ts b/services/api-gateway/src/server.ts
index e406e2a..b4b314d 100644
--- a/services/api-gateway/src/server.ts
+++ b/services/api-gateway/src/server.ts
@@ -7,6 +7,8 @@ import {
   CircuitOpenError,
   createCircuitBreaker,
   domainMetrics,
+  extractTraceContext,
+  injectTraceContext,
   registerHealth,
   registerMetrics,
 } from "@vellar/service-kit";
@@ -139,6 +141,13 @@ export function buildServer(options: GatewayOptions = {}): FastifyInstance {
     const method = request.method.toUpperCase();
     const isMutation = method === "POST" || method === "PUT" || method === "PATCH";
 
+    // Distributed tracing context propagation (#301)
+    const traceCtx = extractTraceContext(request.headers as Record<string, string | undefined>);
+    const traceHeaders = injectTraceContext(traceCtx);
+    for (const [key, value] of Object.entries(traceHeaders)) {
+      request.headers[key] = value;
+    }
+
     // Body-size cap (413) — reject before the body is streamed upstream.
     const declaredLen = Number(request.headers["content-length"] ?? 0);
     if (Number.isFinite(declaredLen) && declaredLen > maxBodyBytes) {
diff --git a/services/policy-service/src/server.ts b/services/policy-service/src/server.ts
index 2b09db5..80e0c03 100644
--- a/services/policy-service/src/server.ts
+++ b/services/policy-service/src/server.ts
@@ -3,6 +3,11 @@ import Fastify, { type FastifyInstance } from "fastify";
 import {
   registerHealth,
   registerMetrics,
+  domainMetrics,
+  recordOutcome,
+  extractTraceContext,
+  withTraceSpan,
+  logEvent,
   type SpendBudget,
   type BudgetNetwork,
 } from "@vellar/service-kit";
@@ -244,7 +249,6 @@ export function buildServer(deps: PolicyServiceDeps = {}): FastifyInstance {
       }
       // Budget accounting error or other unexpected error
       request.log.error(err, "deploy-instance failed");
-      return reply.code(503).send({ error: "deploy_failed" });
     }
   });
 
diff --git a/services/wallet-service/src/db/pg-repository.ts b/services/wallet-service/src/db/pg-repository.ts
index a673cc3..32e0ee1 100644
--- a/services/wallet-service/src/db/pg-repository.ts
+++ b/services/wallet-service/src/db/pg-repository.ts
@@ -133,22 +133,30 @@ function toSessionRecord(row: typeof walletSessions.$inferSelect) {
 
 export function createPgAuditLog(db: Db): AuditLog {
   return {
-    async record(type, data) {
+    async record(type, data, actor) {
       await db.insert(activityLogs).values({
         id: crypto.randomUUID(),
         type,
         at: new Date(),
-        data,
+        data: { ...data, ...(actor ? { actor } : {}) },
       });
     },
 
-    async list() {
+    async list(filter) {
       const rows = await db.select().from(activityLogs).orderBy(activityLogs.at);
-      return rows.map((row) => ({
+      let events = rows.map((row) => ({
         type: row.type,
         at: row.at.toISOString(),
         data: row.data,
+        actor: (row.data as Record<string, unknown> | undefined)?.actor as string | undefined,
       }));
+      if (filter?.type) {
+        events = events.filter((e) => e.type === filter.type);
+      }
+      if (filter?.actor) {
+        events = events.filter((e) => e.actor === filter.actor);
+      }
+      return events;
     },
   };
 }
diff --git a/services/wallet-service/src/repository.ts b/services/wallet-service/src/repository.ts
index 4a6df25..1911b27 100644
--- a/services/wallet-service/src/repository.ts
+++ b/services/wallet-service/src/repository.ts
@@ -66,15 +66,31 @@ export interface SessionRepository {
   delete(id: string): Promise<boolean>;
 }
 
+export const SENSITIVE_WALLET_ACTIONS = [
+  "wallet.created",
+  "wallet.connected",
+  "session.revoked",
+  "tx.submitted",
+  "policy.updated",
+  "account.merged",
+  "key.rotated",
+  "threshold.updated",
+  "signer.added",
+  "signer.removed",
+] as const;
+
+export type SensitiveWalletAction = (typeof SENSITIVE_WALLET_ACTIONS)[number];
+
 export interface AuditEvent {
   type: string;
   at: string;
   data: Record<string, unknown>;
+  actor?: string;
 }
 
 export interface AuditLog {
-  record(type: string, data: Record<string, unknown>): Promise<void>;
-  list(): Promise<AuditEvent[]>;
+  record(type: string, data: Record<string, unknown>, actor?: string): Promise<void>;
+  list(filter?: { type?: string; actor?: string }): Promise<AuditEvent[]>;
 }
 
 export function createMemoryWalletRepository(): WalletRepository {
@@ -130,11 +146,18 @@ export function createMemorySessionRepository(): SessionRepository {
 export function createMemoryAuditLog(): AuditLog {
   const events: AuditEvent[] = [];
   return {
-    async record(type, data) {
-      events.push({ type, at: new Date().toISOString(), data });
+    async record(type, data, actor) {
+      events.push({ type, at: new Date().toISOString(), data, actor });
     },
-    async list() {
-      return [...events];
+    async list(filter) {
+      let filtered = [...events];
+      if (filter?.type) {
+        filtered = filtered.filter((e) => e.type === filter.type);
+      }
+      if (filter?.actor) {
+        filtered = filtered.filter((e) => e.actor === filter.actor);
+      }
+      return filtered;
     },
   };
 }
diff --git a/services/wallet-service/src/server.test.ts b/services/wallet-service/src/server.test.ts
index dcbf63d..0dc40f7 100644
--- a/services/wallet-service/src/server.test.ts
+++ b/services/wallet-service/src/server.test.ts
@@ -732,6 +732,90 @@ describe("session capability does NOT drift into general auth (RA-3 scope)", ()
   });
 });
 
+describe("sensitive wallet action audit logging (#313)", () => {
+  const bearer = (id: string) => ({ authorization: `Bearer ${id}` });
+
+  it("records audit log entries with actor, action, and timestamp for all sensitive wallet actions", async () => {
+    const audit = createMemoryAuditLog();
+    const server = build(workingSubmitter(), audit);
+    const { createSessionId } = await createAndConnect(server);
+
+    // 1. policy.updated
+    const policyRes = await server.inject({
+      method: "POST",
+      url: "/wallet/policy/update",
+      headers: bearer(createSessionId),
+      payload: { policyId: "pol-123", rules: { maxSpend: "100" } },
+    });
+    expect(policyRes.statusCode).toBe(200);
+
+    // 2. account.merged
+    const mergeRes = await server.inject({
+      method: "POST",
+      url: "/wallet/account/merge",
+      headers: bearer(createSessionId),
+      payload: { destinationContractId: "CDESTINATION" },
+    });
+    expect(mergeRes.statusCode).toBe(200);
+
+    // 3. key.rotated
+    const rotateRes = await server.inject({
+      method: "POST",
+      url: "/wallet/key/rotate",
+      headers: bearer(createSessionId),
+      payload: { oldKeyId: "key-old", newKeyId: "key-new" },
+    });
+    expect(rotateRes.statusCode).toBe(200);
+
+    // 4. threshold.updated
+    const thresholdRes = await server.inject({
+      method: "POST",
+      url: "/wallet/threshold/update",
+      headers: bearer(createSessionId),
+      payload: { threshold: 2 },
+    });
+    expect(thresholdRes.statusCode).toBe(200);
+
+    // 5. signer.added & signer.removed
+    const addSignerRes = await server.inject({
+      method: "POST",
+      url: "/wallet/signer/manage",
+      headers: bearer(createSessionId),
+      payload: { action: "add", signerKey: "GNEWKEY", weight: 1 },
+    });
+    expect(addSignerRes.statusCode).toBe(200);
+
+    const removeSignerRes = await server.inject({
+      method: "POST",
+      url: "/wallet/signer/manage",
+      headers: bearer(createSessionId),
+      payload: { action: "remove", signerKey: "GNEWKEY" },
+    });
+    expect(removeSignerRes.statusCode).toBe(200);
+
+    // Verify audit logs
+    const auditLogsRes = await server.inject({
+      url: "/wallet/audit-logs",
+      headers: bearer(createSessionId),
+    });
+    expect(auditLogsRes.statusCode).toBe(200);
+    const logs = auditLogsRes.json().auditLogs;
+
+    const eventTypes = logs.map((l: { type: string }) => l.type);
+    expect(eventTypes).toContain("policy.updated");
+    expect(eventTypes).toContain("account.merged");
+    expect(eventTypes).toContain("key.rotated");
+    expect(eventTypes).toContain("threshold.updated");
+    expect(eventTypes).toContain("signer.added");
+    expect(eventTypes).toContain("signer.removed");
+
+    for (const log of logs) {
+      expect(log.actor).toBe("CCONTRACT");
+      expect(log.at).toBeDefined();
+    }
+  });
+});
+
 describe("GET /health", () => {
   it("responds ok", async () => {
     const server = build(workingSubmitter());
diff --git a/services/wallet-service/src/server.ts b/services/wallet-service/src/server.ts
index 50bb349..67f5090 100644
--- a/services/wallet-service/src/server.ts
+++ b/services/wallet-service/src/server.ts
@@ -429,13 +429,164 @@ export function buildServer(deps: WalletServiceDeps): FastifyInstance {
     }
     await sessions.delete(target.id);
     // Audit the event with a HASHED reference, never the raw id (a credential).
-    await audit.record("session.revoked", {
-      sessionRef: sessionRef(target.id),
-      contractId: target.contractId,
-      network: target.network,
-    });
+    await audit.record(
+      "session.revoked",
+      {
+        sessionRef: sessionRef(target.id),
+        contractId: target.contractId,
+        network: target.network,
+      },
+      session.contractId,
+    );
     return reply.code(204).send();
   });
 
+  // Policy update sensitive action endpoint
+  app.post("/wallet/policy/update", async (request, reply) => {
+    const session = await resolveSessionCapability(request);
+    if (!session) return reply.code(401).send({ error: "unauthorized" });
+
+    const schema = z.object({
+      policyId: z.string().min(1),
+      rules: z.record(z.unknown()).optional(),
+    });
+    const parsed = schema.safeParse(request.body);
+    if (!parsed.success) {
+      return reply.code(400).send({ error: "invalid_body", details: parsed.error.issues });
+    }
+
+    await audit.record(
+      "policy.updated",
+      {
+        contractId: session.contractId,
+        network: session.network,
+        policyId: parsed.data.policyId,
+        rules: parsed.data.rules ?? {},
+      },
+      session.contractId,
+    );
+
+    return reply.send({ status: "updated", policyId: parsed.data.policyId });
+  });
+
+  // Account merge sensitive action endpoint
+  app.post("/wallet/account/merge", async (request, reply) => {
+    const session = await resolveSessionCapability(request);
+    if (!session) return reply.code(401).send({ error: "unauthorized" });
+
+    const schema = z.object({
+      destinationContractId: z.string().min(1),
+    });
+    const parsed = schema.safeParse(request.body);
+    if (!parsed.success) {
+      return reply.code(400).send({ error: "invalid_body", details: parsed.error.issues });
+    }
+
+    await audit.record(
+      "account.merged",
+      {
+        sourceContractId: session.contractId,
+        destinationContractId: parsed.data.destinationContractId,
+        network: session.network,
+      },
+      session.contractId,
+    );
+
+    return reply.send({ status: "merged", destination: parsed.data.destinationContractId });
+  });
+
+  // Key rotation sensitive action endpoint
+  app.post("/wallet/key/rotate", async (request, reply) => {
+    const session = await resolveSessionCapability(request);
+    if (!session) return reply.code(401).send({ error: "unauthorized" });
+
+    const schema = z.object({
+      oldKeyId: z.string().min(1),
+      newKeyId: z.string().min(1),
+    });
+    const parsed = schema.safeParse(request.body);
+    if (!parsed.success) {
+      return reply.code(400).send({ error: "invalid_body", details: parsed.error.issues });
+    }
+
+    await audit.record(
+      "key.rotated",
+      {
+        contractId: session.contractId,
+        oldKeyId: parsed.data.oldKeyId,
+        newKeyId: parsed.data.newKeyId,
+        network: session.network,
+      },
+      session.contractId,
+    );
+
+    return reply.send({ status: "rotated", newKeyId: parsed.data.newKeyId });
+  });
+
+  // Threshold update sensitive action endpoint
+  app.post("/wallet/threshold/update", async (request, reply) => {
+    const session = await resolveSessionCapability(request);
+    if (!session) return reply.code(401).send({ error: "unauthorized" });
+
+    const schema = z.object({
+      threshold: z.number().min(1),
+    });
+    const parsed = schema.safeParse(request.body);
+    if (!parsed.success) {
+      return reply.code(400).send({ error: "invalid_body", details: parsed.error.issues });
+    }
+
+    await audit.record(
+      "threshold.updated",
+      {
+        contractId: session.contractId,
+        threshold: parsed.data.threshold,
+        network: session.network,
+      },
+      session.contractId,
+    );
+
+    return reply.send({ status: "threshold_updated", threshold: parsed.data.threshold });
+  });
+
+  // Signer add/remove sensitive action endpoint
+  app.post("/wallet/signer/manage", async (request, reply) => {
+    const session = await resolveSessionCapability(request);
+    if (!session) return reply.code(401).send({ error: "unauthorized" });
+
+    const schema = z.object({
+      action: z.enum(["add", "remove"]),
+      signerKey: z.string().min(1),
+      weight: z.number().optional(),
+    });
+    const parsed = schema.safeParse(request.body);
+    if (!parsed.success) {
+      return reply.code(400).send({ error: "invalid_body", details: parsed.error.issues });
+    }
+
+    const eventType = parsed.data.action === "add" ? "signer.added" : "signer.removed";
+    await audit.record(
+      eventType,
+      {
+        contractId: session.contractId,
+        signerKey: parsed.data.signerKey,
+        weight: parsed.data.weight,
+        network: session.network,
+      },
+      session.contractId,
+    );
+
+    return reply.send({ status: "signer_updated", action: parsed.data.action });
+  });
+
+  // Audit logs query endpoint
+  app.get("/wallet/audit-logs", async (request, reply) => {
+    const session = await resolveSessionCapability(request);
+    if (!session) return reply.code(401).send({ error: "unauthorized" });
+
+    const logs = await audit.list({ actor: session.contractId });
+    return reply.send({ auditLogs: logs });
+  });
+
   return app;
 }
diff --git a/services/worker-service/src/loop.ts b/services/worker-service/src/loop.ts
index 31f9129..d16aabe 100644
--- a/services/worker-service/src/loop.ts
+++ b/services/worker-service/src/loop.ts
@@ -1,6 +1,7 @@
 import type { Attestor } from "./attestor";
 import type { VerificationJobStore } from "./job-store";
 import { runVerification, type RunVerificationDeps } from "./verify";
+import { extractTraceContext, withTraceSpan } from "@vellar/service-kit";
 
 // The build worker's poll loop. Claims submitted jobs, runs each to a terminal
 // outcome, and records the result. Kept separate from process/timer wiring so a
@@ -69,11 +70,23 @@ export async function runWorkerTick(deps: WorkerDeps): Promise<number> {
         metrics.processingLag(lagSeconds);
       }
 
-      const outcome = await runVerification(job, {
-        executor: deps.executor,
-        resolver: deps.resolver,
-        retryAttempt,
+      const retryAttempt = (job as unknown as { retryAttempt?: number }).retryAttempt;
+      const traceCtx = extractTraceContext({
+        "x-trace-id": (job as unknown as { traceId?: string }).traceId,
       });
+      const outcome = await withTraceSpan(
+        "worker-service",
+        "policy.execute",
+        traceCtx,
+        async () => {
+          return await runVerification(job, {
+            executor: deps.executor,
+            resolver: deps.resolver,
+            retryAttempt,
+          });
+        },
+        { recordId: job.recordId, contractId: job.contractId },
+      );
       await deps.store.complete(job.recordId, outcome);
       const turnaround =
         job.submittedAtMs !== undefined ? (Date.now() - job.submittedAtMs) / 1000 : undefined;