@@ -1,6 +1,6 @@
 import { createHash, randomUUID } from "node:crypto";
 import { type EmbedClientConfig, probeEmbedDims } from "./embed-client.ts";
-import { log } from "../log.ts";
+import { formatCaughtError, log } from "../log.ts";
 
 // Dims are dynamic and discovered, never hard-coded — the dimension travels
 // with exactly one artifact: the knowledge_embed_model.dims column,
@@ -102,12 +102,10 @@ export async function activateEmbedModel(
       [],
     );
   } catch (err) {
+    const errMessage = formatCaughtError(err);
     log.warn(
-      "embed-model-registry: hnsw index creation failed; falling back to ivfflat",
-      {
-        indexName,
-        error: err instanceof Error ? err.message : String(err),
-      },
+      `embed-model-registry: hnsw index creation failed; falling back to ivfflat: ${errMessage}`,
+      { indexName, error: errMessage },
     );
     await client.query(
       `CREATE INDEX IF NOT EXISTS ${indexName} ON ${tableName} USING ivfflat (embedding vector_cosine_ops) WITH (lists = 100)`,
 
@@ -30,6 +30,16 @@ export type { KnowledgePlane } from "./knowledge.ts";
 export { CaptureLog, type CaptureEvent } from "./capture-log.ts";
 // Migrations
 export { runKnowledgeMigrations } from "./migrations.ts";
+// Degrade metrics — no metrics dependency exists in this package (see
+// core/degrade-metrics.ts); a host with its own metrics backend polls this
+// snapshot and forwards it, rather than the engine owning a /metrics port.
+export {
+  getDegradeMetricsSnapshot,
+  getAllDegradeMetricsSnapshots,
+  configureDegradeMetrics,
+  type DegradeMetricsSnapshot,
+  type DegradeMetricsConfig,
+} from "./core/degrade-metrics.ts";
 // Granular mount (compose your own)
 export { mountKnowledgeRoutes, type GrantConfig } from "./routes/mount.ts";
 
 
@@ -3,7 +3,7 @@
  * and hybrid-search services directly — no HTTP hop.
  */
 import type { EngineConfig } from "./config.ts";
-import { log } from "./log.ts";
+import { formatCaughtError, log } from "./log.ts";
 import { createDb, type Db, type RawSql } from "./db/client.ts";
 import type { VisibilitySpec } from "./core/schemas/document.ts";
 import { captureDocument } from "./services/capture.ts";
@@ -87,12 +87,14 @@ export function createKnowledgePlane(config: KnowledgeConfig): KnowledgePlane {
           let list: unknown;
           try {
             list = JSON.parse(raw);
-          } catch {
+          } catch (err) {
             // Unparseable block list → fail closed: hide the doc rather than
             // risk surfacing something a corrupt ACL meant to block.
-            log.warn("search: unparseable acl_block, blocking document", {
-              documentId: row.id,
-            });
+            const errMessage = formatCaughtError(err);
+            log.warn(
+              `search: unparseable acl_block, blocking document: ${errMessage}`,
+              { documentId: row.id, error: errMessage },
+            );
             blocked.add(row.id);
             continue;
           }
 
@@ -0,0 +1,26 @@
+import { describe, expect, it } from "bun:test";
+import { formatCaughtError } from "./log.ts";
+import { RerankHttpError } from "./core/rerank-client.ts";
+
+describe("formatCaughtError", () => {
+  it("returns an Error's message, unchanged", () => {
+    expect(formatCaughtError(new Error("boom"))).toBe("boom");
+  });
+
+  it("carries a RerankHttpError's full diagnostic message (status, url, body) through untouched — this is the exact detail CL-4599 was dropping at render time", () => {
+    const err = new RerankHttpError(
+      413,
+      '{"error":"Input validation error: `inputs` must have less than 512 tokens. Given: 855"}',
+      "https://rerank.example/rerank",
+    );
+    const message = formatCaughtError(err);
+    expect(message).toContain("413");
+    expect(message).toContain("https://rerank.example/rerank");
+    expect(message).toContain("must have less than 512 tokens");
+  });
+
+  it("stringifies a non-Error thrown value rather than dropping it", () => {
+    expect(formatCaughtError("plain string throw")).toBe("plain string throw");
+    expect(formatCaughtError(42)).toBe("42");
+  });
+});
@@ -2,3 +2,14 @@ import { getLogger } from "@intx/log";
 
 /** Category-bound logger for the knowledge engine (uses the host's sinks). */
 export const log = getLogger(["knowledge-engine"]);
+
+// Some `@intx/log` sinks do not render a call's context object into the
+// terminal/aggregator output — only the message string is guaranteed to
+// reach a human. Every catch site in the search path must therefore
+// interpolate the caught error's detail directly into the log message
+// template, not rely solely on passing it as a structured context field.
+// This is the single place that formats "whatever got thrown" into a string
+// worth reading, so every call site produces the same shape.
+export function formatCaughtError(err: unknown): string {
+  return err instanceof Error ? err.message : String(err);
+}
@@ -3,7 +3,7 @@ import type { TenantEnv } from "@intx/hub-api";
 import { describeRoute, resolver, validator } from "hono-openapi";
 import { type } from "arktype";
 
-import { log } from "../log.ts";
+import { formatCaughtError, log } from "../log.ts";
 import { parseAcl } from "../acl.ts";
 import type { RouteDeps } from "./deps.ts";
 import { caller, grantGuard } from "./deps.ts";
@@ -60,7 +60,8 @@ export function mountCaptureRoute(app: Hono<TenantEnv>, deps: RouteDeps): void {
         });
         return c.json({ status: "captured" });
       } catch (err) {
-        log.error("knowledge capture failed", { err });
+        const errMessage = formatCaughtError(err);
+        log.error(`knowledge capture failed: ${errMessage}`, { error: errMessage });
         return c.json({ error: "capture failed" }, 502);
       }
     },
 
@@ -3,7 +3,7 @@ import type { TenantEnv } from "@intx/hub-api";
 import { describeRoute, resolver, validator } from "hono-openapi";
 import { type } from "arktype";
 
-import { log } from "../log.ts";
+import { formatCaughtError, log } from "../log.ts";
 import { KnowledgeError } from "../knowledge.ts";
 import { SearchResponseSchema } from "../core/schemas/search.ts";
 import type { RouteDeps } from "./deps.ts";
@@ -45,7 +45,8 @@ export function mountSearchRoute(app: Hono<TenantEnv>, deps: RouteDeps): void {
         });
         return c.json(result);
       } catch (err) {
-        log.error("knowledge search failed", { err });
+        const errMessage = formatCaughtError(err);
+        log.error(`knowledge search failed: ${errMessage}`, { err });
         if (err instanceof KnowledgeError) {
           return c.json({ error: err.message }, err.status as 400);
         }
 
@@ -4,7 +4,7 @@ import { and, desc, eq } from "drizzle-orm";
 import type { Db, RawSql } from "../db/client.ts";
 import type { EngineConfig } from "../config.ts";
 import { newId } from "../core/id.ts";
-import { log } from "../log.ts";
+import { formatCaughtError, log } from "../log.ts";
 import { stableStringify } from "../core/hash.ts";
 import { LIVE_GENERATION } from "../core/generation.ts";
 import {
@@ -517,27 +517,26 @@ async function embedInsertedChunksWithConfig(
     );
 
     if (result.clientError) {
-      log.warn("capture: embedding client failed; chunks remain pending", {
-        tenantId,
-        chunkCount: chunks.length,
-        error: result.clientError,
-      });
+      log.warn(
+        `capture: embedding client failed; chunks remain pending: ${result.clientError}`,
+        { tenantId, chunkCount: chunks.length, error: result.clientError },
+      );
       return { degraded: true };
     }
     if (result.rejected.length > 0) {
-      log.warn("capture: some chunks were rejected during embedding", {
-        tenantId,
-        rejected: result.rejected,
-      });
+      log.warn(
+        `capture: ${result.rejected.length} chunk(s) rejected during embedding`,
+        { tenantId, rejected: result.rejected },
+      );
       return { degraded: true };
     }
     return { degraded: false };
   } catch (err) {
-    log.warn("capture: embedding pass failed; chunks remain pending", {
-      tenantId,
-      chunkCount: chunks.length,
-      error: err instanceof Error ? err.message : String(err),
-    });
+    const errMessage = formatCaughtError(err);
+    log.warn(
+      `capture: embedding pass failed; chunks remain pending: ${errMessage}`,
+      { tenantId, chunkCount: chunks.length, error: errMessage },
+    );
     return { degraded: true };
   }
 }