diff --git a/README.md b/README.md
index 38de964..38f5d5e 100644
--- a/README.md
+++ b/README.md
@@ -26,6 +26,27 @@ logs --help
 - `logs scan`
 - `logs diagnose`
 
+### Compact Output Defaults
+
+CLI list/status/search commands are compact by default so agent terminals do not
+fill with large records. Human output uses capped row counts, shortened IDs, and
+truncated long text.
+
+Use gradual disclosure when you need more:
+
+```bash
+logs list --limit 25 --offset 25
+logs list --verbose
+logs list --json
+logs events list --json --include-raw
+logs events get <event_id>
+logs test-reports get <report_id>
+logs health --json
+```
+
+Most list commands support `--limit`; larger result sets print a next-page
+offset hint. Detail commands and `--json` retain full machine-readable records.
+
 ## MCP Server
 
 ```bash
@@ -34,6 +55,10 @@ logs-mcp
 
 Includes log search, raw event search/watch/export, projected test-report search/get, storage sync, scan, issue, and performance tools.
 
+MCP list/search/status tools also default to compact payloads. Pass
+`brief: false`, `verbose: true`, `include_raw: true`, or use a `*_get` detail
+tool when an agent needs the complete object.
+
 ## HTTP mode
 
 Run a shared Streamable HTTP MCP server (127.0.0.1 only):
diff --git a/src/cli/compact-output.test.ts b/src/cli/compact-output.test.ts
new file mode 100644
index 0000000..95d67a7
--- /dev/null
+++ b/src/cli/compact-output.test.ts
@@ -0,0 +1,148 @@
+import { describe, expect, test } from "bun:test";
+import { spawnSync } from "node:child_process";
+import { mkdtempSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+
+const repoRoot = join(dirname(fileURLToPath(import.meta.url)), "../..");
+
+function runCli(args: string[], dataDir: string) {
+  return spawnSync("bun", ["src/cli/index.ts", ...args], {
+    cwd: repoRoot,
+    encoding: "utf8",
+    env: {
+      ...process.env,
+      HASNA_LOGS_DATA_DIR: dataDir,
+      HASNA_LOGS_DB_PATH: join(dataDir, "logs.db"),
+      HASNA_LOGS_FSYNC: "0",
+    },
+  });
+}
+
+describe("compact CLI output", () => {
+  test("logs list is compact by default and preserves full JSON output", () => {
+    const dataDir = mkdtempSync(join(tmpdir(), "open-logs-compact-list-"));
+    const longMessage = `compact output canary ${"x".repeat(220)} end`;
+    const longMetadata = JSON.stringify({
+      payload: "metadata ".repeat(80),
+      nested: { secret_shape: "not printed in compact table output" },
+    });
+
+    try {
+      const push = runCli(
+        [
+          "push",
+          longMessage,
+          "--id",
+          "compact-log-1",
+          "--level",
+          "error",
+          "--service",
+          "compact-service-with-long-name",
+          "--trace",
+          "compact-trace-1",
+        ],
+        dataDir,
+      );
+      expect(push.status).toBe(0);
+
+      const dbPatch = spawnSync(
+        "bun",
+        [
+          "-e",
+          `import { Database } from "bun:sqlite"; const db = new Database(${JSON.stringify(join(dataDir, "logs.db"))}); db.prepare("UPDATE logs SET metadata = ? WHERE id = ?").run(${JSON.stringify(longMetadata)}, "compact-log-1"); db.close();`,
+        ],
+        { cwd: repoRoot, encoding: "utf8" },
+      );
+      expect(dbPatch.status).toBe(0);
+
+      const compact = runCli(["list", "--limit", "1"], dataDir);
+      expect(compact.status).toBe(0);
+      expect(compact.stdout).toContain("compact output canary");
+      expect(compact.stdout).toContain("Use --verbose");
+      expect(compact.stdout).not.toContain("end");
+      expect(compact.stdout).not.toContain("metadata metadata metadata");
+      expect(compact.stdout).not.toContain("secret_shape");
+
+      const json = runCli(["list", "--limit", "1", "--json"], dataDir);
+      expect(json.status).toBe(0);
+      const rows = JSON.parse(json.stdout) as Array<{
+        message: string;
+        metadata: string | null;
+      }>;
+      expect(rows[0]?.message).toBe(longMessage);
+      expect(rows[0]?.metadata).toBe(longMetadata);
+    } finally {
+      rmSync(dataDir, { recursive: true, force: true });
+    }
+  });
+
+  test("events list is compact by default and points to detail/json paths", () => {
+    const dataDir = mkdtempSync(join(tmpdir(), "open-logs-compact-events-"));
+    const longEventId = "compact-event-id-abcdefghijklmnopqrstuvwxyz1234567890";
+    const longMessage = `event compact canary ${"y".repeat(220)} end`;
+
+    try {
+      const push = runCli(
+        [
+          "events",
+          "push",
+          "--type",
+          "agent",
+          "--id",
+          longEventId,
+          "--source",
+          "cli-test",
+          "--severity",
+          "warn",
+          "--message",
+          longMessage,
+          "--attributes",
+          JSON.stringify({ noisy: "attributes ".repeat(80) }),
+        ],
+        dataDir,
+      );
+      expect(push.status).toBe(0);
+
+      const compact = runCli(["events", "list", "--limit", "1"], dataDir);
+      expect(compact.status).toBe(0);
+      expect(compact.stdout).toContain(longEventId);
+      expect(compact.stdout).toContain("event compact canary");
+      expect(compact.stdout).toContain("events get <event_id>");
+      expect(compact.stdout).not.toContain("end");
+      expect(compact.stdout).not.toContain("attributes attributes");
+
+      const json = runCli(
+        ["events", "list", "--limit", "1", "--json", "--include-raw"],
+        dataDir,
+      );
+      expect(json.status).toBe(0);
+      const rows = JSON.parse(json.stdout) as Array<{
+        message: string | null;
+        raw?: { message?: string | null };
+      }>;
+      expect(rows[0]?.message).toBe(longMessage);
+      expect(rows[0]?.raw?.message).toBe(longMessage);
+    } finally {
+      rmSync(dataDir, { recursive: true, force: true });
+    }
+  });
+
+  test("health is summarized by default and full with --json", () => {
+    const dataDir = mkdtempSync(join(tmpdir(), "open-logs-compact-health-"));
+    try {
+      const compact = runCli(["health"], dataDir);
+      expect(compact.status).toBe(0);
+      expect(compact.stdout).toContain("Health: ok");
+      expect(compact.stdout).toContain("Use --verbose");
+      expect(() => JSON.parse(compact.stdout)).toThrow();
+
+      const json = runCli(["health", "--json"], dataDir);
+      expect(json.status).toBe(0);
+      expect(JSON.parse(json.stdout)).toMatchObject({ status: "ok" });
+    } finally {
+      rmSync(dataDir, { recursive: true, force: true });
+    }
+  });
+});
diff --git a/src/cli/index.ts b/src/cli/index.ts
index 199bd2a..71ea2a7 100644
--- a/src/cli/index.ts
+++ b/src/cli/index.ts
@@ -69,6 +69,11 @@ const LEVEL_COLOR: Record<string, string> = {
   info: "",
   debug: C.gray,
 };
+const DEFAULT_HUMAN_LIMIT = 25;
+const DEFAULT_JSON_LIMIT = 100;
+const MAX_HUMAN_FIELD = 96;
+const MAX_MESSAGE_FIELD = 140;
+
 function colorRow(ts: string, level: string, svc: string, msg: string): string {
   const lc = LEVEL_COLOR[level.toLowerCase()] ?? "";
   const isTTY = process.stdout.isTTY;
@@ -112,6 +117,78 @@ function printJson(value: unknown): void {
   console.log(JSON.stringify(value, null, 2));
 }
 
+function compactText(
+  value: string | null | undefined,
+  max = MAX_HUMAN_FIELD,
+): string {
+  if (!value) return "-";
+  const singleLine = value.replace(/\s+/g, " ").trim();
+  if (singleLine.length <= max) return singleLine;
+  return `${singleLine.slice(0, Math.max(0, max - 3))}...`;
+}
+
+function compactId(value: string | null | undefined, max = 16): string {
+  if (!value) return "-";
+  if (value.length <= max) return value;
+  return `${value.slice(0, max - 1)}...`;
+}
+
+function compactTimestamp(value: string | null | undefined): string {
+  return value ? value.slice(0, 19) : "-";
+}
+
+function parseListLimit(
+  value: string | undefined,
+  label: string,
+  fallback = DEFAULT_HUMAN_LIMIT,
+): number {
+  return parsePositiveIntOption(value, label, fallback);
+}
+
+function parseListOffset(value: string | undefined): number {
+  return parseOptionalNonNegativeInt(value, "--offset") ?? 0;
+}
+
+function splitVisibleRows<T>(
+  rows: T[],
+  limit: number,
+): { rows: T[]; hasMore: boolean } {
+  return {
+    rows: rows.slice(0, limit),
+    hasMore: rows.length > limit,
+  };
+}
+
+function printCompactFooter(opts: {
+  command: string;
+  count: number;
+  noun: string;
+  limit: number;
+  offset?: number;
+  hasMore?: boolean;
+  detailHint?: string;
+}): void {
+  const offset = opts.offset ?? 0;
+  const range =
+    offset > 0
+      ? `offset ${offset}, showing ${opts.count}`
+      : `showing ${opts.count}`;
+  console.log(`\n${range} ${opts.noun}(s).`);
+  if (opts.hasMore) {
+    console.log(
+      `More results available. Use ${opts.command} --limit ${opts.limit} --offset ${offset + opts.limit} for the next page.`,
+    );
+  }
+  if (opts.detailHint) console.log(opts.detailHint);
+}
+
+function tableFormat(opts: {
+  format?: string;
+  json?: boolean;
+}): string {
+  return opts.json ? "json" : (opts.format ?? "table");
+}
+
 function parseJsonObjectOption(
   value: string | undefined,
   label: string,
@@ -207,12 +284,23 @@ program
     "Until timestamp or relative (e.g. logs list --since 2h --until 1h)",
   )
   .option("--text <query>", "Full-text search")
-  .option("--limit <n>", "Max results", "100")
+  .option("--limit <n>", "Max results (default: 25 for table, 100 for JSON)")
+  .option("--offset <n>", "Skip this many results for pagination")
+  .option("--verbose", "Show full messages and metadata in table output")
+  .option("--json", "Alias for --format json")
   .option("--format <fmt>", "Output format: table|json|compact", "table")
   .action((opts) => {
     const db = getDb();
     const since = parseRelativeTime(opts.since);
     const until = parseRelativeTime(opts.until);
+    const format = tableFormat(opts);
+    const isJson = format === "json";
+    const limit = parseListLimit(
+      opts.limit,
+      "--limit",
+      isJson ? DEFAULT_JSON_LIMIT : DEFAULT_HUMAN_LIMIT,
+    );
+    const offset = parseListOffset(opts.offset);
     const rows = searchLogs(db, {
       project_id: resolveProject(opts.project),
       page_id: opts.page,
@@ -221,26 +309,41 @@ program
       since,
       until,
       text: opts.text,
-      limit: Number(opts.limit),
+      limit: isJson ? limit : limit + 1,
+      offset,
     });
-    if (opts.format === "json") {
-      console.log(JSON.stringify(rows, null, 2));
+    if (isJson) {
+      printJson(rows);
       return;
     }
-    if (opts.format === "compact") {
-      for (const r of rows)
+    const visible = splitVisibleRows(rows, limit);
+    if (format === "compact") {
+      for (const r of visible.rows)
         console.log(
-          `${r.timestamp} [${r.level.toUpperCase()}] ${r.service ?? "-"} ${r.message}`,
+          `${compactTimestamp(r.timestamp)} [${r.level.toUpperCase()}] ${compactText(r.service, 18)} ${compactText(r.message, MAX_MESSAGE_FIELD)}`,
         );
       return;
     }
-    for (const r of rows) {
-      const meta = r.metadata ? ` ${r.metadata}` : "";
+    for (const r of visible.rows) {
+      const message = opts.verbose
+        ? r.message
+        : compactText(r.message, MAX_MESSAGE_FIELD);
+      const service = compactText(r.service, 18);
+      const meta = opts.verbose && r.metadata ? ` metadata=${r.metadata}` : "";
       console.log(
-        `${colorRow(r.timestamp, r.level, r.service ?? "-", r.message)}${meta}`,
+        `${colorRow(compactTimestamp(r.timestamp), r.level, service, message)}  id=${compactId(r.id)}${r.trace_id ? ` trace=${compactId(r.trace_id)}` : ""}${meta}`,
       );
     }
-    console.log(`\n${rows.length} log(s)`);
+    printCompactFooter({
+      command: "logs list",
+      count: visible.rows.length,
+      noun: "log",
+      limit,
+      offset,
+      hasMore: visible.hasMore,
+      detailHint:
+        "Use --verbose for full messages/metadata or --json for full records.",
+    });
   });
 
 // ── logs tail ──────────────────────────────────────────────
@@ -248,15 +351,31 @@ program
   .command("tail")
   .description("Show most recent logs")
   .option("--project <name|id>", "Project name or ID")
-  .option("--n <count>", "Number of logs", "50")
+  .option("--n <count>", "Number of logs", String(DEFAULT_HUMAN_LIMIT))
+  .option("--verbose", "Show full messages in table output")
+  .option("--json", "Output full records as JSON")
   .action((opts) => {
-    const rows = tailLogs(
-      getDb(),
-      resolveProject(opts.project),
-      Number(opts.n),
-    );
-    for (const r of rows)
-      console.log(colorRow(r.timestamp, r.level, r.service ?? "-", r.message));
+    const limit = parseListLimit(opts.n, "--n", DEFAULT_HUMAN_LIMIT);
+    const rows = tailLogs(getDb(), resolveProject(opts.project), limit);
+    if (opts.json) {
+      printJson(rows);
+      return;
+    }
+    for (const r of rows) {
+      const message = opts.verbose
+        ? r.message
+        : compactText(r.message, MAX_MESSAGE_FIELD);
+      console.log(
+        `${colorRow(compactTimestamp(r.timestamp), r.level, compactText(r.service, 18), message)}  id=${compactId(r.id)}`,
+      );
+    }
+    printCompactFooter({
+      command: "logs tail",
+      count: rows.length,
+      noun: "log",
+      limit,
+      detailHint: "Use --verbose for full messages or --json for full records.",
+    });
   });
 
 // ── logs summary ──────────────────────────────────────────
@@ -457,6 +576,7 @@ const storageCmd = program
 storageCmd
   .command("status")
   .description("Show storage sync configuration")
+  .option("--verbose", "Show the full table list")
   .option("--json", "Output as JSON")
   .action((opts) => {
     const info = getStorageStatus();
@@ -466,7 +586,13 @@ storageCmd
     }
     console.log(`Storage configured: ${info.configured ? "yes" : "no"}`);
     console.log(`Mode: ${info.mode}`);
-    console.log(`Tables: ${info.tables.join(", ")}`);
+    if (opts.verbose) {
+      console.log(`Tables (${info.tables.length}): ${info.tables.join(", ")}`);
+    } else {
+      console.log(
+        `Tables: ${info.tables.length} service-owned table(s). Use --verbose to list names.`,
+      );
+    }
   });
 
 storageCmd
@@ -747,9 +873,20 @@ eventsCmd
     "Substring search over event id, source id, message, and metadata",
   )
   .option("--include-raw", "Include raw segment envelope")
-  .option("--limit <n>", "Max results", "100")
+  .option("--limit <n>", "Max results (default: 25 for table, 100 for JSON)")
+  .option("--offset <n>", "Skip this many results for pagination")
+  .option("--verbose", "Show wider event fields in table output")
+  .option("--json", "Alias for --format json")
   .option("--format <fmt>", "Output format: table|json", "table")
   .action((opts) => {
+    const format = tableFormat(opts);
+    const isJson = format === "json";
+    const limit = parseListLimit(
+      opts.limit,
+      "--limit",
+      isJson ? DEFAULT_JSON_LIMIT : DEFAULT_HUMAN_LIMIT,
+    );
+    const offset = parseListOffset(opts.offset);
     const rows = searchEvents(getDb(), {
       event_type: opts.type,
       source: opts.source,
@@ -766,19 +903,36 @@ eventsCmd
       since: parseRelativeTime(opts.since),
       until: parseRelativeTime(opts.until),
       text: opts.text,
-      include_raw: Boolean(opts.includeRaw),
-      limit: Number(opts.limit),
+      include_raw: Boolean(opts.includeRaw) && isJson,
+      limit: isJson ? limit : limit + 1,
+      offset,
     });
-    if (opts.format === "json") {
+    if (isJson) {
       printJson(rows);
       return;
     }
-    for (const row of rows) {
+    const visible = splitVisibleRows(rows, limit);
+    for (const row of visible.rows) {
+      const message = opts.verbose
+        ? (row.message ?? "")
+        : compactText(row.message, MAX_MESSAGE_FIELD);
       console.log(
-        `${row.event_time}  ${pad(row.event_type, 10)} ${pad(row.source, 8)} ${pad(row.severity ?? "-", 5)} ${row.event_id}  ${row.message ?? ""}`,
+        `${compactTimestamp(row.event_time)}  ${pad(compactText(row.event_type, 10), 10)} ${pad(compactText(row.source, 10), 10)} ${pad(row.severity ?? "-", 5)} ${row.event_id}  ${message}`,
       );
     }
-    console.log(`\n${rows.length} event(s)`);
+    printCompactFooter({
+      command: "logs events list",
+      count: visible.rows.length,
+      noun: "event",
+      limit,
+      offset,
+      hasMore: visible.hasMore,
+      detailHint:
+        "Use events get <event_id> for one record, --verbose for wider rows, or --json for full records.",
+    });
+    if (opts.includeRaw) {
+      console.log("Raw envelopes are available with --include-raw --json.");
+    }
   });
 
 eventsCmd
@@ -873,9 +1027,20 @@ testReportsCmd
   .option("--until <time>", "Until timestamp or relative")
   .option("--text <query>", "Substring search over report and case metadata")
   .option("--include-cases", "Include bounded case rows")
-  .option("--limit <n>", "Max results", "100")
+  .option("--limit <n>", "Max results (default: 25 for table, 100 for JSON)")
+  .option("--offset <n>", "Skip this many results for pagination")
+  .option("--verbose", "Show wider report fields in table output")
+  .option("--json", "Alias for --format json")
   .option("--format <fmt>", "Output format: table|json", "table")
   .action((opts) => {
+    const format = tableFormat(opts);
+    const isJson = format === "json";
+    const limit = parseListLimit(
+      opts.limit,
+      "--limit",
+      isJson ? DEFAULT_JSON_LIMIT : DEFAULT_HUMAN_LIMIT,
+    );
+    const offset = parseListOffset(opts.offset);
     const rows = searchTestReports(getDb(), {
       report_id: opts.report,
       event_id: opts.event,
@@ -898,20 +1063,36 @@ testReportsCmd
       since: parseRelativeTime(opts.since),
       until: parseRelativeTime(opts.until),
       text: opts.text,
-      include_cases: Boolean(opts.includeCases),
-      limit: Number(opts.limit),
+      include_cases: Boolean(opts.includeCases) && isJson,
+      limit: isJson ? limit : limit + 1,
+      offset,
     });
-    if (opts.format === "json") {
+    if (isJson) {
       printJson(rows);
       return;
     }
-    for (const report of rows) {
+    const visible = splitVisibleRows(rows, limit);
+    for (const report of visible.rows) {
       const counts = `${report.tests ?? "-"} tests/${report.failures ?? "-"} failures/${report.errors ?? "-"} errors`;
       console.log(
-        `${report.event_time ?? "-"}  ${pad(report.parse_status ?? "-", 10)} ${pad(report.parser ?? "-", 14)} ${pad(counts, 30)} ${report.id}  ${report.path ?? ""}`,
+        `${compactTimestamp(report.event_time)}  ${pad(compactText(report.parse_status, 10), 10)} ${pad(compactText(report.parser, 14), 14)} ${pad(counts, 30)} ${report.id}  ${compactText(report.path, opts.verbose ? 160 : 80)}`,
+      );
+    }
+    printCompactFooter({
+      command: "logs test-reports list",
+      count: visible.rows.length,
+      noun: "test report",
+      limit,
+      offset,
+      hasMore: visible.hasMore,
+      detailHint:
+        "Use test-reports get <report_id> for cases/details, --verbose for wider rows, or --json for full records.",
+    });
+    if (opts.includeCases) {
+      console.log(
+        "Case rows are included only with --include-cases --json or test-reports get.",
       );
     }
-    console.log(`\n${rows.length} test report(s)`);
   });
 
 testReportsCmd
@@ -949,13 +1130,36 @@ projectCmd
     console.log(`Created project: ${p.id} — ${p.name}`);
   });
 
-projectCmd.command("list").action(() => {
-  const projects = listProjects(getDb());
-  for (const p of projects)
-    console.log(
-      `${p.id}  ${p.name}  ${p.base_url ?? ""}  ${p.github_repo ?? ""}`,
-    );
-});
+projectCmd
+  .command("list")
+  .option("--limit <n>", "Max results", String(DEFAULT_HUMAN_LIMIT))
+  .option("--offset <n>", "Skip this many results for pagination")
+  .option("--verbose", "Show full URLs and repository fields")
+  .option("--json", "Output full records as JSON")
+  .action((opts) => {
+    const limit = parseListLimit(opts.limit, "--limit", DEFAULT_HUMAN_LIMIT);
+    const offset = parseListOffset(opts.offset);
+    const projects = listProjects(getDb());
+    const page = projects.slice(offset, offset + limit + 1);
+    if (opts.json) {
+      printJson(projects.slice(offset, offset + limit));
+      return;
+    }
+    const visible = splitVisibleRows(page, limit);
+    for (const p of visible.rows)
+      console.log(
+        `${compactId(p.id)}  ${compactText(p.name, 28)}  ${compactText(p.base_url, opts.verbose ? 120 : 40)}  ${compactText(p.github_repo, opts.verbose ? 120 : 40)}`,
+      );
+    printCompactFooter({
+      command: "logs project list",
+      count: visible.rows.length,
+      noun: "project",
+      limit,
+      offset,
+      hasMore: visible.hasMore,
+      detailHint: "Use --verbose for wider fields or --json for full records.",
+    });
+  });
 
 // ── logs page ─────────────────────────────────────────────
 const pageCmd = program.command("page").description("Manage pages");
@@ -986,6 +1190,10 @@ pageCmd
 pageCmd
   .command("list")
   .option("--project <name|id>", "Project name or ID")
+  .option("--limit <n>", "Max results", String(DEFAULT_HUMAN_LIMIT))
+  .option("--offset <n>", "Skip this many results for pagination")
+  .option("--verbose", "Show full URLs")
+  .option("--json", "Output full records as JSON")
   .action((opts) => {
     if (!opts.project) {
       console.error("--project required");
@@ -996,9 +1204,28 @@ pageCmd
       console.error("Project not found");
       process.exit(1);
     }
+    const limit = parseListLimit(opts.limit, "--limit", DEFAULT_HUMAN_LIMIT);
+    const offset = parseListOffset(opts.offset);
     const pages = listPages(getDb(), projectId);
-    for (const p of pages)
-      console.log(`${p.id}  ${p.url}  last=${p.last_scanned_at ?? "never"}`);
+    const page = pages.slice(offset, offset + limit + 1);
+    if (opts.json) {
+      printJson(pages.slice(offset, offset + limit));
+      return;
+    }
+    const visible = splitVisibleRows(page, limit);
+    for (const p of visible.rows)
+      console.log(
+        `${compactId(p.id)}  ${compactText(p.url, opts.verbose ? 160 : 80)}  last=${compactTimestamp(p.last_scanned_at)}`,
+      );
+    printCompactFooter({
+      command: "logs page list",
+      count: visible.rows.length,
+      noun: "page",
+      limit,
+      offset,
+      hasMore: visible.hasMore,
+      detailHint: "Use --verbose for full URLs or --json for full records.",
+    });
   });
 
 // ── logs job ──────────────────────────────────────────────
@@ -1028,12 +1255,32 @@ jobCmd
 jobCmd
   .command("list")
   .option("--project <name|id>", "Project name or ID")
+  .option("--limit <n>", "Max results", String(DEFAULT_HUMAN_LIMIT))
+  .option("--offset <n>", "Skip this many results for pagination")
+  .option("--json", "Output full records as JSON")
   .action((opts) => {
+    const limit = parseListLimit(opts.limit, "--limit", DEFAULT_HUMAN_LIMIT);
+    const offset = parseListOffset(opts.offset);
     const jobs = listJobs(getDb(), resolveProject(opts.project));
-    for (const j of jobs)
+    const page = jobs.slice(offset, offset + limit + 1);
+    if (opts.json) {
+      printJson(jobs.slice(offset, offset + limit));
+      return;
+    }
+    const visible = splitVisibleRows(page, limit);
+    for (const j of visible.rows)
       console.log(
-        `${j.id}  ${j.schedule}  enabled=${j.enabled}  last=${j.last_run_at ?? "never"}`,
+        `${compactId(j.id)}  ${compactText(j.schedule, 24)}  enabled=${j.enabled}  last=${compactTimestamp(j.last_run_at)}`,
       );
+    printCompactFooter({
+      command: "logs job list",
+      count: visible.rows.length,
+      noun: "job",
+      limit,
+      offset,
+      hasMore: visible.hasMore,
+      detailHint: "Use --json for full records.",
+    });
   });
 
 // ── logs scan ─────────────────────────────────────────────
@@ -1068,6 +1315,8 @@ program
     "--include <items>",
     "Comma-separated: top_errors,error_rate,failing_pages,perf",
   )
+  .option("--verbose", "Show wider messages and URLs")
+  .option("--json", "Output full diagnosis as JSON")
   .action(async (opts) => {
     const { diagnose } = await import("../lib/diagnose.ts");
     const projectId = resolveProject(opts.project);
@@ -1077,6 +1326,10 @@ program
     }
     const include = opts.include ? opts.include.split(",") : undefined;
     const result = diagnose(getDb(), projectId, opts.since, include);
+    if (opts.json) {
+      printJson(result);
+      return;
+    }
     const scoreColor =
       result.score === "green"
         ? "\x1b[32m"
@@ -1090,7 +1343,7 @@ program
       console.log(`\n${C.bold}Top Errors:${C.reset}`);
       for (const e of result.top_errors) {
         console.log(
-          `  ${C.red}${pad(String(e.count), 5)}x${C.reset}  ${C.cyan}${pad(e.service ?? "-", 12)}${C.reset}  ${e.message}`,
+          `  ${C.red}${pad(String(e.count), 5)}x${C.reset}  ${C.cyan}${pad(compactText(e.service, 12), 12)}${C.reset}  ${opts.verbose ? e.message : compactText(e.message, MAX_MESSAGE_FIELD)}`,
         );
       }
     }
@@ -1108,18 +1361,23 @@ program
       console.log(`\n${C.bold}Failing Pages:${C.reset}`);
       for (const p of result.failing_pages)
         console.log(
-          `  ${C.red}✗${C.reset}  ${p.url}  (${p.error_count} errors)`,
+          `  ${C.red}✗${C.reset}  ${compactText(p.url, opts.verbose ? 160 : 88)}  (${p.error_count} errors)`,
         );
     }
     if (result.perf_regressions?.length) {
       console.log(`\n${C.bold}Perf Regressions:${C.reset}`);
       for (const r of result.perf_regressions)
         console.log(
-          `  ${C.yellow}⚠${C.reset}  ${r.url}  score=${r.score_now ?? "-"} delta=${r.delta ?? "-"}`,
+          `  ${C.yellow}⚠${C.reset}  ${compactText(r.url, opts.verbose ? 160 : 88)}  score=${r.score_now ?? "-"} delta=${r.delta ?? "-"}`,
         );
     }
-    console.log(`\n${result.summary}`);
+    console.log(
+      `\n${opts.verbose ? result.summary : compactText(result.summary, 220)}`,
+    );
     console.log("");
+    console.log(
+      "Use --verbose for wider rows or --json for the full diagnosis object.",
+    );
   });
 
 // ── logs watch ────────────────────────────────────────────
@@ -1446,10 +1704,29 @@ program
 program
   .command("health")
   .description("Show server health and DB stats")
-  .action(async () => {
+  .option("--json", "Output full health object as JSON")
+  .option("--verbose", "Show level breakdown")
+  .action(async (opts) => {
     const { getHealth } = await import("../lib/health.ts");
     const h = getHealth(getDb());
-    console.log(JSON.stringify(h, null, 2));
+    if (opts.json) {
+      printJson(h);
+      return;
+    }
+    console.log(
+      `Health: ${h.status}  logs=${h.total_logs.toLocaleString()}  projects=${h.projects}  jobs=${h.scheduler_jobs}  open_issues=${h.open_issues}`,
+    );
+    console.log(
+      `Window: oldest=${compactTimestamp(h.oldest_log)} newest=${compactTimestamp(h.newest_log)} uptime=${h.uptime_seconds}s`,
+    );
+    if (opts.verbose) {
+      console.log(`By level: ${JSON.stringify(h.logs_by_level)}`);
+      console.log(`DB size: ${h.db_size_bytes ?? "-"} bytes`);
+    } else {
+      console.log(
+        "Use --verbose for level breakdown or --json for the full health object.",
+      );
+    }
   });
 
 // ── logs mcp / logs serve ─────────────────────────────────
diff --git a/src/mcp/index.test.ts b/src/mcp/index.test.ts
index 37ff1a9..fea017c 100644
--- a/src/mcp/index.test.ts
+++ b/src/mcp/index.test.ts
@@ -6,6 +6,8 @@ import { join } from "node:path";
 import { fileURLToPath } from "node:url";
 import { Client } from "@modelcontextprotocol/sdk/client/index.js";
 import { StdioClientTransport } from "@modelcontextprotocol/sdk/client/stdio.js";
+import { ingestLog } from "../lib/ingest.ts";
+import { upsertIssue } from "../lib/issues.ts";
 
 const entry = fileURLToPath(new URL("./index.ts", import.meta.url));
 
@@ -194,6 +196,85 @@ test("logs MCP watches event catalog records by cursor", async () => {
   }
 });
 
+test("MCP log_context_from_id keeps the target log when capped", async () => {
+  const dataDir = mkdtempSync(join(tmpdir(), "open-logs-mcp-context-cap-"));
+  const { client, transport } = createMcpClient(dataDir);
+
+  try {
+    await client.connect(transport);
+    const db = new Database(join(dataDir, "logs.db"));
+    try {
+      for (let i = 0; i < 40; i += 1) {
+        ingestLog(db, {
+          id: `context-cap-${String(i).padStart(2, "0")}`,
+          timestamp: `2026-01-01T00:00:${String(i).padStart(2, "0")}.000Z`,
+          level: "info",
+          message: `context cap row ${i}`,
+          trace_id: "context-cap-trace",
+        });
+      }
+    } finally {
+      db.close();
+    }
+
+    const result = await client.callTool({
+      name: "log_context_from_id",
+      arguments: {
+        log_id: "context-cap-34",
+        limit: 5,
+      },
+    });
+    const rows = JSON.parse(textContent(result)) as Array<{ id: string }>;
+    expect(rows).toHaveLength(5);
+    expect(rows.map((row) => row.id)).toContain("context-cap-34");
+  } finally {
+    await client.close().catch(() => {});
+    rmSync(dataDir, { recursive: true, force: true });
+  }
+});
+
+test("MCP list_issues compacts long issue messages by default", async () => {
+  const dataDir = mkdtempSync(join(tmpdir(), "open-logs-mcp-issues-compact-"));
+  const { client, transport } = createMcpClient(dataDir);
+  const longMessage = `issue compact canary ${"z".repeat(240)} end`;
+
+  try {
+    await client.connect(transport);
+    const db = new Database(join(dataDir, "logs.db"));
+    try {
+      upsertIssue(db, {
+        level: "error",
+        service: "issue-service-with-a-long-name",
+        message: longMessage,
+      });
+    } finally {
+      db.close();
+    }
+
+    const result = await client.callTool({
+      name: "list_issues",
+      arguments: {},
+    });
+    const rows = JSON.parse(textContent(result)) as Array<{
+      message_template: string;
+    }>;
+    expect(rows[0]?.message_template).toContain("issue compact canary");
+    expect(rows[0]?.message_template).not.toContain(" end");
+
+    const full = await client.callTool({
+      name: "list_issues",
+      arguments: { brief: false },
+    });
+    const fullRows = JSON.parse(textContent(full)) as Array<{
+      message_template: string;
+    }>;
+    expect(fullRows[0]?.message_template).toBe(longMessage);
+  } finally {
+    await client.close().catch(() => {});
+    rmSync(dataDir, { recursive: true, force: true });
+  }
+});
+
 test("MCP queries projected test reports", async () => {
   const dataDir = mkdtempSync(join(tmpdir(), "open-logs-mcp-test-reports-"));
   const { client, transport } = createMcpClient(dataDir);
@@ -478,7 +559,27 @@ test("MCP event_search and event_watch hide internal tool telemetry by default",
         limit: 20,
       },
     });
-    const internalRows = JSON.parse(textContent(internalSearch)) as Array<{
+    const compactInternalRows = JSON.parse(
+      textContent(internalSearch),
+    ) as Array<{
+      message: string;
+      metadata?: unknown;
+      has_metadata?: boolean;
+    }>;
+    expect(compactInternalRows.some((row) => row.has_metadata)).toBe(true);
+    expect(compactInternalRows.some((row) => row.metadata)).toBe(false);
+
+    const fullInternalSearch = await client.callTool({
+      name: "event_search",
+      arguments: {
+        event_type: "agent",
+        source: "mcp",
+        include_internal: true,
+        brief: false,
+        limit: 20,
+      },
+    });
+    const internalRows = JSON.parse(textContent(fullInternalSearch)) as Array<{
       message: string;
       metadata: Record<string, unknown> | null;
     }>;
diff --git a/src/mcp/index.ts b/src/mcp/index.ts
index ed538c3..c6678d6 100644
--- a/src/mcp/index.ts
+++ b/src/mcp/index.ts
@@ -84,6 +84,9 @@ export function buildServer(): McpServer {
     "message",
     "service",
   ];
+  const MCP_DEFAULT_LIMIT = 25;
+  const MCP_MAX_LIMIT = 1_000;
+  const MCP_TEXT_LIMIT = 160;
 
   // biome-ignore lint/suspicious/noExplicitAny: MCP SDK tool handlers are dynamically typed from their Zod schemas.
   type McpToolHandler = (...args: any[]) => any;
@@ -103,14 +106,111 @@ export function buildServer(): McpServer {
       id: r.id,
       timestamp: r.timestamp,
       level: r.level,
-      message: r.message,
-      service: r.service,
+      message: compactMcpText(r.message, MCP_TEXT_LIMIT),
+      service: compactMcpText(r.service, 48),
       age_seconds: Math.floor(
         (Date.now() - new Date(r.timestamp).getTime()) / 1000,
       ),
     }));
   }
 
+  function compactMcpText(
+    value: string | null | undefined,
+    max = MCP_TEXT_LIMIT,
+  ): string | null {
+    if (value === null || value === undefined) return null;
+    const singleLine = value.replace(/\s+/g, " ").trim();
+    if (singleLine.length <= max) return singleLine;
+    return `${singleLine.slice(0, Math.max(0, max - 3))}...`;
+  }
+
+  function clampMcpListLimit(
+    value: number | undefined,
+    fallback = MCP_DEFAULT_LIMIT,
+  ): number {
+    if (!Number.isFinite(value) || value === undefined) return fallback;
+    return Math.min(Math.max(1, Math.floor(value)), MCP_MAX_LIMIT);
+  }
+
+  function resolveMcpContextLimit(
+    value: number | undefined,
+    brief: boolean | undefined,
+    total: number,
+  ): number {
+    if (value !== undefined) return clampMcpListLimit(value);
+    return brief === false ? total : MCP_DEFAULT_LIMIT;
+  }
+
+  function sliceMcpContextRows(
+    rows: LogRow[],
+    limit: number,
+    targetLogId?: string,
+  ): LogRow[] {
+    if (limit <= 0 || rows.length <= limit) return rows;
+    if (!targetLogId) return rows.slice(0, limit);
+    const targetIndex = rows.findIndex((row) => row.id === targetLogId);
+    if (targetIndex < 0 || targetIndex < limit) return rows.slice(0, limit);
+    const halfWindow = Math.floor(limit / 2);
+    const start = Math.min(
+      Math.max(0, targetIndex - halfWindow),
+      Math.max(0, rows.length - limit),
+    );
+    return rows.slice(start, start + limit);
+  }
+
+  function compactMcpEvent(row: EventCatalogEntry): Record<string, unknown> {
+    return {
+      event_id: row.event_id,
+      event_time: row.event_time,
+      event_type: row.event_type,
+      source: row.source,
+      severity: row.severity,
+      project_id: row.project_id,
+      trace_id: row.trace_id,
+      run_id: row.run_id,
+      message: compactMcpText(row.message),
+      has_metadata: Boolean(row.metadata && Object.keys(row.metadata).length),
+      has_raw: Boolean(row.raw),
+    };
+  }
+
+  function compactMcpTestReport(report: {
+    id: string;
+    event_id: string | null;
+    event_time: string | null;
+    parser: string | null;
+    parse_status: string | null;
+    path: string | null;
+    tests: number | null;
+    failures: number | null;
+    errors: number | null;
+    skipped: number | null;
+    case_stored_count: number;
+    truncated: boolean;
+  }): Record<string, unknown> {
+    return {
+      id: report.id,
+      event_id: report.event_id,
+      event_time: report.event_time,
+      parser: report.parser,
+      parse_status: report.parse_status,
+      path: compactMcpText(report.path, 120),
+      tests: report.tests,
+      failures: report.failures,
+      errors: report.errors,
+      skipped: report.skipped,
+      case_stored_count: report.case_stored_count,
+      truncated: report.truncated,
+    };
+  }
+
+  function compactObjectFields<T extends Record<string, unknown>>(
+    value: T,
+    fields: Array<keyof T>,
+  ): Record<string, unknown> {
+    return Object.fromEntries(fields.map((field) => [field, value[field]]));
+  }
+
   function rp(idOrName?: string): string | undefined {
     if (!idOrName) return undefined;
     return resolveProjectId(db, idOrName) ?? idOrName;
@@ -152,11 +252,11 @@ export function buildServer(): McpServer {
     log_search: {
       desc: "Search logs",
       params:
-        "(project_id?, level?, since?, until?, text?, service?, limit?=100, brief?=true)",
+        "(project_id?, level?, since?, until?, text?, service?, limit?=25, brief?=true)",
     },
     log_tail: {
       desc: "Get N most recent logs",
-      params: "(project_id?, n?=50, brief?=true)",
+      params: "(project_id?, n?=25, brief?=true)",
     },
     log_count: {
       desc: "Count logs — zero token cost, pure signal",
@@ -171,12 +271,12 @@ export function buildServer(): McpServer {
       params: "(project_id?, since?)",
     },
     log_context: {
-      desc: "All logs for a trace_id",
-      params: "(trace_id, brief?=true)",
+      desc: "Logs for a trace_id; brief mode is capped by default",
+      params: "(trace_id, brief?=true, limit?=25)",
     },
     log_context_from_id: {
-      desc: "Trace context from a log ID (no trace_id needed)",
-      params: "(log_id, brief?=true)",
+      desc: "Trace context from a log ID; brief mode is capped by default",
+      params: "(log_id, brief?=true, limit?=25, window?=0)",
     },
     log_export: {
       desc: "Export matching logs as JSON or CSV",
@@ -204,7 +304,7 @@ export function buildServer(): McpServer {
     event_search: {
       desc: "Search raw-backed event_records across event types and identity dimensions",
       params:
-        "(event_type?, source?, severity?, project_id?, machine_id?, repo_id?, app_id?, process_id?, run_id?, trace_id?, session_id?, text?, limit?=100, include_raw?=false, include_internal?=false)",
+        "(event_type?, source?, severity?, project_id?, machine_id?, repo_id?, app_id?, process_id?, run_id?, trace_id?, session_id?, text?, limit?=25, brief?=true, include_raw?=false, include_internal?=false)",
     },
     event_get: {
       desc: "Get one event record and optionally reconstruct its raw segment envelope",
@@ -218,12 +318,12 @@ export function buildServer(): McpServer {
     event_watch: {
       desc: "Poll event_records after a cursor for MCP live-tail consumers",
       params:
-        "(last_event_id?, event_type?, source?, severity?, project_id?, trace_id?, run_id?, limit?=100, include_raw?=false, from_start?=false, include_internal?=false)",
+        "(last_event_id?, event_type?, source?, severity?, project_id?, trace_id?, run_id?, limit?=25, brief?=true, include_raw?=false, from_start?=false, include_internal?=false)",
     },
     test_report_search: {
       desc: "Search projected test_reports and optionally include bounded test_cases",
       params:
-        "(report_id?, event_id?, project_id?, run_id?, process_id?, parser?, parse_status?, case_status?, outcome?, min_failures?, min_errors?, text?, limit?=100, include_cases?=false)",
+        "(report_id?, event_id?, project_id?, run_id?, process_id?, parser?, parse_status?, case_status?, outcome?, min_failures?, min_errors?, text?, limit?=25, brief?=true, include_cases?=false)",
     },
     test_report_get: {
       desc: "Get one projected test report with bounded test case rows by default",
@@ -237,12 +337,21 @@ export function buildServer(): McpServer {
       desc: "Performance over time",
       params: "(project_id, page_id?, since?, limit?=50)",
     },
-    scan_status: { desc: "Last scan jobs", params: "(project_id?)" },
-    list_projects: { desc: "List all projects", params: "()" },
-    list_pages: { desc: "List pages for a project", params: "(project_id)" },
+    scan_status: {
+      desc: "Last scan jobs",
+      params: "(project_id?, limit?=25, brief?=true)",
+    },
+    list_projects: {
+      desc: "List all projects",
+      params: "(limit?=25, brief?=true)",
+    },
+    list_pages: {
+      desc: "List pages for a project",
+      params: "(project_id, limit?=25, brief?=true)",
+    },
     list_issues: {
       desc: "List grouped error issues",
-      params: "(project_id?, status?, limit?=50)",
+      params: "(project_id?, status?, limit?=25, brief?=true)",
     },
     resolve_issue: {
       desc: "Update issue status",
@@ -253,14 +362,23 @@ export function buildServer(): McpServer {
       params:
         "(project_id, name, level?, threshold_count?, window_seconds?, webhook_url?)",
     },
-    list_alert_rules: { desc: "List alert rules", params: "(project_id?)" },
+    list_alert_rules: {
+      desc: "List alert rules",
+      params: "(project_id?, limit?=25, brief?=true)",
+    },
     delete_alert_rule: { desc: "Delete alert rule", params: "(id)" },
-    get_health: { desc: "Server health + DB stats", params: "()" },
+    get_health: {
+      desc: "Server health + DB stats",
+      params: "(verbose?=false)",
+    },
     log_stats: {
       desc: "Aggregate DB-level log statistics for a project",
       params: "(project_id?)",
     },
-    storage_status: { desc: "Show storage sync configuration", params: "()" },
+    storage_status: {
+      desc: "Show storage sync configuration",
+      params: "(verbose?=false)",
+    },
     storage_push: {
       desc: "Push local logs data to storage PostgreSQL",
       params: "(tables?)",
@@ -508,6 +626,7 @@ export function buildServer(): McpServer {
         level: args.level ? (args.level.split(",") as LogLevel[]) : undefined,
         since: parseTime(args.since) ?? args.since,
         until: parseTime(args.until) ?? args.until,
+        limit: clampMcpListLimit(args.limit),
       });
       return {
         content: [
@@ -528,7 +647,7 @@ export function buildServer(): McpServer {
       brief: z.boolean().optional(),
     },
     ({ project_id, n, brief }) => {
-      const rows = tailLogs(db, rp(project_id), n ?? 50);
+      const rows = tailLogs(db, rp(project_id), clampMcpListLimit(n));
       return {
         content: [
           {
@@ -612,17 +731,23 @@ export function buildServer(): McpServer {
     {
       trace_id: z.string(),
       brief: z.boolean().optional(),
+      limit: z.number().optional(),
+    },
+    ({ trace_id, brief, limit }) => {
+      const allRows = getLogContext(db, trace_id);
+      const rows = sliceMcpContextRows(
+        allRows,
+        resolveMcpContextLimit(limit, brief, allRows.length),
+      );
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify(applyBrief(rows, brief !== false)),
+          },
+        ],
+      };
     },
-    ({ trace_id, brief }) => ({
-      content: [
-        {
-          type: "text",
-          text: JSON.stringify(
-            applyBrief(getLogContext(db, trace_id), brief !== false),
-          ),
-        },
-      ],
-    }),
   );
 
   registerTool(
@@ -630,6 +755,7 @@ export function buildServer(): McpServer {
     {
       log_id: z.string(),
       brief: z.boolean().optional(),
+      limit: z.number().optional(),
       window: z
         .number()
         .int()
@@ -639,19 +765,22 @@ export function buildServer(): McpServer {
           "Return N logs before and after the target log's timestamp (in addition to trace context)",
         ),
     },
-    ({ log_id, brief, window }) => ({
-      content: [
-        {
-          type: "text",
-          text: JSON.stringify(
-            applyBrief(
-              getLogContextFromId(db, log_id, window ?? 0),
-              brief !== false,
-            ),
-          ),
-        },
-      ],
-    }),
+    ({ log_id, brief, limit, window }) => {
+      const allRows = getLogContextFromId(db, log_id, window ?? 0);
+      const rows = sliceMcpContextRows(
+        allRows,
+        resolveMcpContextLimit(limit, brief, allRows.length),
+        log_id,
+      );
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify(applyBrief(rows, brief !== false)),
+          },
+        ],
+      };
+    },
   );
 
   registerTool(
@@ -850,25 +979,30 @@ export function buildServer(): McpServer {
       limit: z.number().optional(),
       include_raw: z.boolean().optional(),
       include_internal: z.boolean().optional(),
+      brief: z.boolean().optional(),
+    },
+    (args) => {
+      const wantsFullRows = args.brief === false || args.include_raw === true;
+      const rows = searchEvents(db, {
+        ...args,
+        project_id: rp(args.project_id),
+        since: parseTime(args.since) ?? args.since,
+        until: parseTime(args.until) ?? args.until,
+        limit: clampMcpListLimit(args.limit),
+        include_raw: args.include_raw === true,
+        exclude_mcp_tool_telemetry: args.include_internal !== true,
+      });
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify(
+              wantsFullRows ? rows : rows.map(compactMcpEvent),
+            ),
+          },
+        ],
+      };
     },
-    (args) => ({
-      content: [
-        {
-          type: "text",
-          text: JSON.stringify(
-            searchEvents(db, {
-              ...args,
-              project_id: rp(args.project_id),
-              since: parseTime(args.since) ?? args.since,
-              until: parseTime(args.until) ?? args.until,
-              limit: args.limit ?? 100,
-              include_raw: args.include_raw === true,
-              exclude_mcp_tool_telemetry: args.include_internal !== true,
-            }),
-          ),
-        },
-      ],
-    }),
   );
 
   registerTool(
@@ -950,6 +1084,7 @@ export function buildServer(): McpServer {
       include_raw: z.boolean().optional(),
       from_start: z.boolean().optional(),
       include_internal: z.boolean().optional(),
+      brief: z.boolean().optional(),
     },
     (args) => ({
       content: [
@@ -959,10 +1094,11 @@ export function buildServer(): McpServer {
             watchEventsForMcp({
               ...args,
               project_id: rp(args.project_id),
-              limit: args.limit ?? 100,
+              limit: clampMcpListLimit(args.limit),
               include_raw: args.include_raw === true,
               from_start: args.from_start === true,
               include_internal: args.include_internal === true,
+              brief: args.brief,
             }),
           ),
         },
@@ -1005,24 +1141,30 @@ export function buildServer(): McpServer {
       text: z.string().optional(),
       limit: z.number().optional(),
       include_cases: z.boolean().optional(),
+      brief: z.boolean().optional(),
+    },
+    (args) => {
+      const rows = searchTestReports(db, {
+        ...args,
+        project_id: rp(args.project_id),
+        since: parseTime(args.since) ?? args.since,
+        until: parseTime(args.until) ?? args.until,
+        limit: clampMcpListLimit(args.limit),
+        include_cases: args.include_cases === true,
+      });
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify(
+              args.brief === false || args.include_cases === true
+                ? rows
+                : rows.map(compactMcpTestReport),
+            ),
+          },
+        ],
+      };
     },
-    (args) => ({
-      content: [
-        {
-          type: "text",
-          text: JSON.stringify(
-            searchTestReports(db, {
-              ...args,
-              project_id: rp(args.project_id),
-              since: parseTime(args.since) ?? args.since,
-              until: parseTime(args.until) ?? args.until,
-              limit: args.limit ?? 100,
-              include_cases: args.include_cases === true,
-            }),
-          ),
-        },
-      ],
-    }),
   );
 
   registerTool(
@@ -1094,26 +1236,94 @@ export function buildServer(): McpServer {
     "scan_status",
     {
       project_id: z.string().optional(),
+      limit: z.number().optional(),
+      brief: z.boolean().optional(),
+    },
+    ({ project_id, limit, brief }) => {
+      const rows = listJobs(db, rp(project_id)).slice(
+        0,
+        clampMcpListLimit(limit),
+      );
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify(
+              brief === false
+                ? rows
+                : rows.map((job) => ({
+                    id: job.id,
+                    project_id: job.project_id,
+                    page_id: job.page_id,
+                    schedule: compactMcpText(job.schedule, 80),
+                    enabled: job.enabled,
+                    last_run_at: job.last_run_at,
+                  })),
+            ),
+          },
+        ],
+      };
     },
-    ({ project_id }) => ({
-      content: [
-        { type: "text", text: JSON.stringify(listJobs(db, rp(project_id))) },
-      ],
-    }),
   );
 
-  registerTool("list_projects", {}, () => ({
-    content: [{ type: "text", text: JSON.stringify(listProjects(db)) }],
-  }));
+  registerTool(
+    "list_projects",
+    { limit: z.number().optional(), brief: z.boolean().optional() },
+    ({ limit, brief }) => {
+      const rows = listProjects(db).slice(0, clampMcpListLimit(limit));
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify(
+              brief === false
+                ? rows
+                : rows.map((project) => ({
+                    id: project.id,
+                    name: compactMcpText(project.name, 80),
+                    base_url: compactMcpText(project.base_url, 100),
+                    github_repo: compactMcpText(project.github_repo, 100),
+                    created_at: project.created_at,
+                  })),
+            ),
+          },
+        ],
+      };
+    },
+  );
 
-  registerTool("list_pages", { project_id: z.string() }, ({ project_id }) => ({
-    content: [
-      {
-        type: "text",
-        text: JSON.stringify(listPages(db, rp(project_id) ?? project_id)),
-      },
-    ],
-  }));
+  registerTool(
+    "list_pages",
+    {
+      project_id: z.string(),
+      limit: z.number().optional(),
+      brief: z.boolean().optional(),
+    },
+    ({ project_id, limit, brief }) => {
+      const rows = listPages(db, rp(project_id) ?? project_id).slice(
+        0,
+        clampMcpListLimit(limit),
+      );
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify(
+              brief === false
+                ? rows
+                : rows.map((page) => ({
+                    id: page.id,
+                    project_id: page.project_id,
+                    url: compactMcpText(page.url, 140),
+                    path: compactMcpText(page.path, 80),
+                    last_scanned_at: page.last_scanned_at,
+                  })),
+            ),
+          },
+        ],
+      };
+    },
+  );
 
   registerTool(
     "list_issues",
@@ -1121,17 +1331,37 @@ export function buildServer(): McpServer {
       project_id: z.string().optional(),
       status: z.string().optional(),
       limit: z.number().optional(),
+      brief: z.boolean().optional(),
+    },
+    ({ project_id, status, limit, brief }) => {
+      const rows = listIssues(
+        db,
+        rp(project_id),
+        status,
+        clampMcpListLimit(limit),
+      );
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify(
+              brief === false
+                ? rows
+                : rows.map((issue) => ({
+                    id: issue.id,
+                    project_id: issue.project_id,
+                    status: issue.status,
+                    level: issue.level,
+                    service: compactMcpText(issue.service, 48),
+                    message_template: compactMcpText(issue.message_template),
+                    count: issue.count,
+                    last_seen: issue.last_seen,
+                  })),
+            ),
+          },
+        ],
+      };
     },
-    ({ project_id, status, limit }) => ({
-      content: [
-        {
-          type: "text",
-          text: JSON.stringify(
-            listIssues(db, rp(project_id), status, limit ?? 50),
-          ),
-        },
-      ],
-    }),
   );
 
   registerTool(
@@ -1181,15 +1411,38 @@ export function buildServer(): McpServer {
     "list_alert_rules",
     {
       project_id: z.string().optional(),
+      limit: z.number().optional(),
+      brief: z.boolean().optional(),
+    },
+    ({ project_id, limit, brief }) => {
+      const rows = listAlertRules(db, rp(project_id)).slice(
+        0,
+        clampMcpListLimit(limit),
+      );
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify(
+              brief === false
+                ? rows
+                : rows.map((rule) =>
+                    compactObjectFields(rule as Record<string, unknown>, [
+                      "id",
+                      "project_id",
+                      "name",
+                      "level",
+                      "service",
+                      "threshold_count",
+                      "window_seconds",
+                      "enabled",
+                    ]),
+                  ),
+            ),
+          },
+        ],
+      };
     },
-    ({ project_id }) => ({
-      content: [
-        {
-          type: "text",
-          text: JSON.stringify(listAlertRules(db, rp(project_id))),
-        },
-      ],
-    }),
   );
 
   registerTool("delete_alert_rule", { id: z.string() }, ({ id }) => {
@@ -1197,9 +1450,32 @@ export function buildServer(): McpServer {
     return { content: [{ type: "text", text: "deleted" }] };
   });
 
-  registerTool("get_health", {}, () => ({
-    content: [{ type: "text", text: JSON.stringify(getHealth(db)) }],
-  }));
+  registerTool(
+    "get_health",
+    { verbose: z.boolean().optional() },
+    ({ verbose }) => {
+      const health = getHealth(db);
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify(
+              verbose === true
+                ? health
+                : {
+                    status: health.status,
+                    total_logs: health.total_logs,
+                    projects: health.projects,
+                    scheduler_jobs: health.scheduler_jobs,
+                    open_issues: health.open_issues,
+                    newest_log: health.newest_log,
+                  },
+            ),
+          },
+        ],
+      };
+    },
+  );
 
   registerTool(
     "log_stats",
@@ -1322,6 +1598,7 @@ export function buildServer(): McpServer {
     include_raw?: boolean;
     from_start?: boolean;
     include_internal?: boolean;
+    brief?: boolean;
   }
 
   interface McpEventCursor {
@@ -1371,7 +1648,15 @@ export function buildServer(): McpServer {
     const last = visibleRows.at(-1);
     if (last) cursor = last.event_id;
 
-    return { events, cursor, has_more: rows.length > limit, overflow };
+    return {
+      events:
+        args.brief === false || args.include_raw === true
+          ? events
+          : events.map((event) => compactMcpEvent(event)),
+      cursor,
+      has_more: rows.length > limit,
+      overflow,
+    };
   }
 
   function latestMcpEventCursor(
@@ -1758,13 +2043,26 @@ export function buildServer(): McpServer {
   registerTrackedTool(
     "list_agents",
     "List all registered agents.",
-    {},
-    async () => {
+    { limit: z.number().optional(), brief: z.boolean().optional() },
+    async ({ limit, brief }) => {
+      const agents = [..._logsAgents.values()].slice(
+        0,
+        clampMcpListLimit(limit),
+      );
       return {
         content: [
           {
             type: "text" as const,
-            text: JSON.stringify([..._logsAgents.values()]),
+            text: JSON.stringify(
+              brief === false
+                ? agents
+                : agents.map((agent) => ({
+                    id: agent.id,
+                    name: compactMcpText(agent.name, 80),
+                    project_id: agent.project_id ?? null,
+                    last_seen_at: agent.last_seen_at,
+                  })),
+            ),
           },
         ],
       };
@@ -1774,12 +2072,27 @@ export function buildServer(): McpServer {
   registerTrackedTool(
     "storage_status",
     "Check configured logs PostgreSQL remote storage.",
-    {},
-    async () => {
+    { verbose: z.boolean().optional() },
+    async ({ verbose }) => {
       const status = getStorageStatus();
       if (!status.configured)
         return {
-          content: [{ type: "text" as const, text: JSON.stringify(status) }],
+          content: [
+            {
+              type: "text" as const,
+              text: JSON.stringify(
+                verbose === true
+                  ? status
+                  : {
+                      configured: status.configured,
+                      mode: status.mode,
+                      service: status.service,
+                      table_count: status.tables.length,
+                      activeEnv: status.activeEnv,
+                    },
+              ),
+            },
+          ],
         };
       let storage: Awaited<ReturnType<typeof getStoragePg>> | null = null;
       try {
@@ -1792,11 +2105,23 @@ export function buildServer(): McpServer {
           content: [
             {
               type: "text" as const,
-              text: JSON.stringify({
-                ...status,
-                connected: true,
-                remoteTables: remoteTables.map((row) => row.tablename),
-              }),
+              text: JSON.stringify(
+                verbose === true
+                  ? {
+                      ...status,
+                      connected: true,
+                      remoteTables: remoteTables.map((row) => row.tablename),
+                    }
+                  : {
+                      configured: status.configured,
+                      mode: status.mode,
+                      service: status.service,
+                      activeEnv: status.activeEnv,
+                      table_count: status.tables.length,
+                      connected: true,
+                      remote_table_count: remoteTables.length,
+                    },
+              ),
             },
           ],
         };