@chrysb/alphaclaw 0.4.6-beta.7 → 0.4.6-beta.8

package/lib/public/js/components/doctor/helpers.js

@@ -1,12 +1,16 @@
 export const getDoctorPriorityTone = (priority = "") => {
-  const normalized = String(priority || "").trim().toUpperCase();
+  const normalized = String(priority || "")
+    .trim()
+    .toUpperCase();
   if (normalized === "P0") return "danger";
   if (normalized === "P1") return "warning";
   return "neutral";
 };
 
 export const getDoctorStatusTone = (status = "") => {
-  const normalized = String(status || "").trim().toLowerCase();
+  const normalized = String(status || "")
+    .trim()
+    .toLowerCase();
   if (normalized === "fixed") return "success";
   if (normalized === "dismissed") return "neutral";
   return "warning";
@@ -35,7 +39,9 @@ export const formatDoctorCategory = (category = "") => {
 export const buildDoctorPriorityCounts = (cards = []) =>
   cards.reduce(
     (totals, card) => {
-      const priority = String(card?.priority || "").trim().toUpperCase();
+      const priority = String(card?.priority || "")
+        .trim()
+        .toUpperCase();
       if (priority === "P0" || priority === "P1" || priority === "P2") {
         totals[priority] += 1;
       }
@@ -47,7 +53,9 @@ export const buildDoctorPriorityCounts = (cards = []) =>
 export const groupDoctorCardsByStatus = (cards = []) =>
   cards.reduce(
     (groups, card) => {
-      const status = String(card?.status || "open").trim().toLowerCase();
+      const status = String(card?.status || "open")
+        .trim()
+        .toLowerCase();
       if (status === "fixed") {
         groups.fixed.push(card);
         return groups;
@@ -74,13 +82,71 @@ export const shouldShowDoctorWarning = (
 
 export const getDoctorWarningMessage = (doctorStatus = null) => {
   if (!doctorStatus) return "";
-  const changedFilesCount = Number(doctorStatus.changeSummary?.changedFilesCount || 0);
+  const changedFilesCount = Number(
+    doctorStatus.changeSummary?.changedFilesCount || 0,
+  );
   if (changedFilesCount > 0) {
     return `Drift Doctor has not been run in the last week and ${changedFilesCount} file${changedFilesCount === 1 ? "" : "s"} changed since the last review.`;
   }
   return "Doctor has not been run in the last week.";
 };
 
+export const formatDoctorCharCount = (value = 0) =>
+  `${Number(value || 0).toLocaleString()} chars`;
+
+const isManagedBootstrapContextPath = (filePath = "") =>
+  String(filePath || "").startsWith("hooks/bootstrap/");
+
+export const getDoctorBootstrapTruncationItems = (doctorStatus = null) => {
+  const bootstrapContext = doctorStatus?.bootstrapContext;
+  const truncatedFiles = (bootstrapContext?.activeTruncatedFiles || []).filter(
+    (file) => !isManagedBootstrapContextPath(file?.path),
+  );
+  const nearLimitFiles = (bootstrapContext?.activeNearLimitFiles || []).filter(
+    (file) => !isManagedBootstrapContextPath(file?.path),
+  );
+  return [
+    ...truncatedFiles.map((file) => ({
+      path: file.path,
+      size: formatDoctorCharCount(file.rawChars),
+      statusText: `-${Number(
+        Math.max(
+          0,
+          Number(file.rawChars || 0) - Number(file.injectedChars || 0),
+        ),
+      ).toLocaleString()} cut`,
+      statusTone: "danger",
+    })),
+    ...nearLimitFiles.map((file) => ({
+      path: file.path,
+      size: formatDoctorCharCount(file.rawChars),
+      statusText: "Near limit",
+      statusTone: "warning",
+    })),
+  ];
+};
+
+export const hasDoctorBootstrapWarnings = (doctorStatus = null) =>
+  getDoctorBootstrapTruncationItems(doctorStatus).length > 0;
+
+export const getDoctorBootstrapWarningTitle = (doctorStatus = null) => {
+  const items = getDoctorBootstrapTruncationItems(doctorStatus);
+  if (!items.length) return "";
+  const hasTruncatedItems = items.some((item) => item.statusTone === "danger");
+  const hasNearLimitItems = items.some((item) => item.statusTone === "warning");
+  if (hasTruncatedItems && hasNearLimitItems) {
+    return "Some of your main files are being truncated or nearing the limit:";
+  }
+  if (hasNearLimitItems) {
+    return items.length === 1
+      ? "One of your main files is nearing the limit:"
+      : "Some of your main files are nearing the limit:";
+  }
+  return items.length === 1
+    ? "One of your main files is being truncated:"
+    : "Some of your main files are being truncated:";
+};
+
 export const getDoctorChangeLabel = (changeSummary = null) => {
   const changedFilesCount = Number(changeSummary?.changedFilesCount || 0);
   if (changedFilesCount === 0) return "No changes since last run";

package/lib/public/js/components/doctor/index.js

@@ -20,8 +20,11 @@ import { DoctorFixCardModal } from "./fix-card-modal.js";
 import {
   buildDoctorRunMarkers,
   buildDoctorStatusFilterOptions,
+  getDoctorBootstrapTruncationItems,
+  getDoctorBootstrapWarningTitle,
   getDoctorChangeLabel,
   getDoctorRunPillDetail,
+  hasDoctorBootstrapWarnings,
   shouldShowDoctorWarning,
 } from "./helpers.js";
 
@@ -182,6 +185,18 @@ export const DoctorTab = ({ isActive = false, onOpenFile = () => {} }) => {
     () => shouldShowDoctorWarning(doctorStatus, 0),
     [doctorStatus],
   );
+  const showBootstrapTruncationBanner = useMemo(
+    () => hasDoctorBootstrapWarnings(doctorStatus),
+    [doctorStatus],
+  );
+  const bootstrapTruncationMessage = useMemo(
+    () => getDoctorBootstrapWarningTitle(doctorStatus),
+    [doctorStatus],
+  );
+  const bootstrapTruncationItems = useMemo(
+    () => getDoctorBootstrapTruncationItems(doctorStatus),
+    [doctorStatus],
+  );
   const hasCompletedDoctorRun = !!doctorStatus?.lastRunAt;
   const hasRuns = runs.length > 0;
   const hasLoadedRuns = runsPoll.data !== null || runsPoll.error !== null;
@@ -312,29 +327,76 @@ export const DoctorTab = ({ isActive = false, onOpenFile = () => {} }) => {
         : null}
       ${!showInitialLoadingState && hasRuns
         ? html`
-            <${DoctorSummaryCards} cards=${openCards} />
-            <div class="space-y-2">
-              ${hasCompletedDoctorRun
-                ? html`
-                    <div
-                      class="bg-surface border border-border rounded-xl p-4 flex flex-wrap items-center justify-between gap-3"
-                    >
-                      <span class="text-xs text-gray-500">
-                        Last run ·${" "}
-                        <span class="text-gray-300">
-                          ${formatLocaleDateTime(doctorStatus?.lastRunAt, {
-                            fallback: "Never",
-                          })}
+            <div class="space-y-3">
+              <${DoctorSummaryCards} cards=${openCards} />
+              <div class="space-y-3">
+                ${hasCompletedDoctorRun
+                  ? html`
+                      <div
+                        class="bg-surface border border-border rounded-xl p-4 flex flex-wrap items-center justify-between gap-3"
+                      >
+                        <span class="text-xs text-gray-500">
+                          Last run ·${" "}
+                          <span class="text-gray-300">
+                            ${formatLocaleDateTime(doctorStatus?.lastRunAt, {
+                              fallback: "Never",
+                            })}
+                          </span>
                         </span>
-                      </span>
-                      <span class="text-xs text-gray-500">
-                        ${changeLabel}
-                      </span>
-                    </div>
-                  `
-                : null}
-              ${
-                showDoctorStaleBanner
+                        <span class="text-xs text-gray-500">
+                          ${changeLabel}
+                        </span>
+                      </div>
+                      ${showBootstrapTruncationBanner
+                        ? html`
+                            <div
+                              class="bg-surface border border-border rounded-xl p-4 space-y-3"
+                            >
+                              <div class="text-xs text-gray-400">
+                                ⚠️ ${bootstrapTruncationMessage}
+                              </div>
+                              <div class="space-y-2">
+                                ${bootstrapTruncationItems.map(
+                                  (item) => html`
+                                    <div
+                                      class="flex items-center justify-between gap-3 text-xs"
+                                    >
+                                      <button
+                                        type="button"
+                                        class="font-mono text-gray-200 ac-tip-link hover:underline text-left cursor-pointer"
+                                        onClick=${() => onOpenFile(String(item.path || ""))}
+                                      >
+                                        ${item.path}
+                                      </button>
+                                      <span
+                                        class="flex items-center gap-3 whitespace-nowrap"
+                                      >
+                                        <span class="text-gray-500">
+                                          ${item.size}
+                                        </span>
+                                        <span
+                                          class=${item.statusTone === "warning"
+                                            ? "text-yellow-300"
+                                            : "text-red-300"}
+                                        >
+                                          ${item.statusText}
+                                        </span>
+                                      </span>
+                                    </div>
+                                  `,
+                                )}
+                              </div>
+                              <div class="border-t border-border"></div>
+                              <p class="text-xs text-gray-500 leading-5">
+                                Truncated files become partially hidden from
+                                your agent and could cause drift.
+                              </p>
+                            </div>
+                          `
+                        : null}
+                    `
+                  : null}
+                ${showDoctorStaleBanner
                   ? html`
                       <div
                         class="text-xs text-yellow-300 bg-yellow-500/10 border border-yellow-500/35 rounded-lg px-3 py-2"
@@ -344,8 +406,8 @@ export const DoctorTab = ({ isActive = false, onOpenFile = () => {} }) => {
                         changed.
                       </div>
                     `
-                  : null
-              }
+                  : null}
+              </div>
             </div>
           `
         : null}
@@ -461,9 +523,7 @@ export const DoctorTab = ({ isActive = false, onOpenFile = () => {} }) => {
               ${selectedRunIsInProgress
                 ? html`
                     <div class="ac-surface-inset rounded-xl p-4">
-                      <div
-                        class="text-xs leading-5 text-gray-400"
-                      >
+                      <div class="text-xs leading-5 text-gray-400">
                         <span
                           >Run in progress. Findings will appear when analysis
                           completes.</span
@@ -479,7 +539,8 @@ export const DoctorTab = ({ isActive = false, onOpenFile = () => {} }) => {
                   onAskAgentFix=${setFixCard}
                   onUpdateStatus=${handleUpdateStatus}
                   onOpenFile=${onOpenFile}
-                  changedPaths=${doctorStatus?.changeSummary?.changedPaths || []}
+                  changedPaths=${doctorStatus?.changeSummary?.changedPaths ||
+                  []}
                   showRunMeta=${selectedRunFilter === "all"}
                   hideEmptyState=${selectedRunIsInProgress}
                 />

package/lib/server/doctor/bootstrap-context.js

@@ -0,0 +1,191 @@
+const fs = require("fs");
+const path = require("path");
+
+const kDoctorBootstrapMaxChars = 20000;
+const kDoctorBootstrapTotalMaxChars = 150000;
+const kDoctorBootstrapNearLimitRatio = 0.9;
+const kDoctorContextTruncationGuidance =
+  "OpenClaw trims oversized injected files by keeping the first 70%, keeping the last 20%, and cutting the middle 10% without a warning.";
+
+const kDoctorRootContextFiles = [
+  { path: "AGENTS.md", injectMode: "always" },
+  { path: "SOUL.md", injectMode: "always" },
+  { path: "TOOLS.md", injectMode: "always" },
+  { path: "IDENTITY.md", injectMode: "always" },
+  { path: "USER.md", injectMode: "always" },
+  { path: "HEARTBEAT.md", injectMode: "always" },
+  { path: "BOOTSTRAP.md", injectMode: "first_run_only" },
+];
+
+const kDoctorBootstrapExtraFiles = [
+  { path: "hooks/bootstrap/AGENTS.md", injectMode: "always" },
+  { path: "hooks/bootstrap/TOOLS.md", injectMode: "always" },
+];
+
+const kDoctorBootstrapContextFiles = [...kDoctorRootContextFiles, ...kDoctorBootstrapExtraFiles];
+
+const readWorkspaceFileChars = (workspaceRoot, relativePath) => {
+  const fullPath = path.join(workspaceRoot, relativePath);
+  try {
+    const content = fs.readFileSync(fullPath, "utf8");
+    return {
+      exists: true,
+      chars: content.length,
+    };
+  } catch {
+    return {
+      exists: false,
+      chars: 0,
+    };
+  }
+};
+
+const analyzeBootstrapContext = ({
+  workspaceRoot = "",
+  bootstrapMaxChars = kDoctorBootstrapMaxChars,
+  bootstrapTotalMaxChars = kDoctorBootstrapTotalMaxChars,
+} = {}) => {
+  const files = kDoctorBootstrapContextFiles.map((spec) => {
+    const fileState = readWorkspaceFileChars(workspaceRoot, spec.path);
+    const rawChars = fileState.chars;
+    const fileLimitChars = Math.min(rawChars, bootstrapMaxChars);
+    const nearFileLimit = rawChars > 0 && rawChars >= Math.floor(bootstrapMaxChars * kDoctorBootstrapNearLimitRatio);
+    return {
+      ...spec,
+      exists: fileState.exists,
+      rawChars,
+      fileLimitChars,
+      injectedChars: 0,
+      truncatedByFileLimit: rawChars > bootstrapMaxChars,
+      truncatedByTotalLimit: false,
+      truncated: rawChars > bootstrapMaxChars,
+      nearFileLimit: nearFileLimit && rawChars <= bootstrapMaxChars,
+      active: spec.injectMode === "always",
+      reason: rawChars > bootstrapMaxChars ? "file_limit" : "",
+    };
+  });
+
+  let injectedTotalChars = 0;
+  for (const file of files) {
+    if (!file.active || !file.exists) continue;
+    const remainingChars = Math.max(0, bootstrapTotalMaxChars - injectedTotalChars);
+    file.injectedChars = Math.min(file.fileLimitChars, remainingChars);
+    file.truncatedByTotalLimit = file.fileLimitChars > file.injectedChars;
+    file.truncated = file.truncatedByFileLimit || file.truncatedByTotalLimit;
+    if (file.truncatedByFileLimit && file.truncatedByTotalLimit) {
+      file.reason = "file_and_total_limit";
+    } else if (file.truncatedByFileLimit) {
+      file.reason = "file_limit";
+    } else if (file.truncatedByTotalLimit) {
+      file.reason = "total_limit";
+    }
+    injectedTotalChars += file.injectedChars;
+  }
+
+  const activeFiles = files.filter((file) => file.active && file.exists);
+  const activeTruncatedFiles = activeFiles.filter((file) => file.truncated);
+  const activeNearLimitFiles = activeFiles.filter((file) => file.nearFileLimit && !file.truncated);
+  const inactiveTruncatedFiles = files.filter((file) => !file.active && file.exists && file.truncated);
+  const hasTotalLimitTruncation = activeTruncatedFiles.some(
+    (file) => file.reason === "total_limit" || file.reason === "file_and_total_limit",
+  );
+
+  return {
+    bootstrapMaxChars,
+    bootstrapTotalMaxChars,
+    truncationGuidance: kDoctorContextTruncationGuidance,
+    files,
+    activeFiles,
+    activeRawChars: activeFiles.reduce((sum, file) => sum + file.rawChars, 0),
+    activeInjectedChars: activeFiles.reduce((sum, file) => sum + file.injectedChars, 0),
+    hasActiveTruncation: activeTruncatedFiles.length > 0,
+    hasActiveNearLimitFiles: activeNearLimitFiles.length > 0,
+    hasActiveWarnings: activeTruncatedFiles.length > 0 || activeNearLimitFiles.length > 0,
+    hasAnyTruncation: activeTruncatedFiles.length > 0 || inactiveTruncatedFiles.length > 0,
+    activeTruncatedFiles,
+    activeNearLimitFiles,
+    inactiveTruncatedFiles,
+    hasTotalLimitTruncation,
+    totalLimitReached: injectedTotalChars >= bootstrapTotalMaxChars,
+  };
+};
+
+const formatChars = (value = 0) => `${Number(value || 0).toLocaleString()} chars`;
+
+const buildBootstrapTruncationCards = (bootstrapContext = null) => {
+  if (!bootstrapContext?.hasActiveTruncation) return [];
+
+  const cards = bootstrapContext.activeTruncatedFiles
+    .filter((file) => file.reason === "file_limit")
+    .map((file) => ({
+      priority: "P0",
+      category: "project context",
+      title: `${file.path} is being truncated in Project Context`,
+      summary:
+        `${file.path} is ${formatChars(file.rawChars)}, above the per-file Project Context limit ` +
+        `of ${formatChars(bootstrapContext.bootstrapMaxChars)}. The agent is not seeing the full file.`,
+      recommendation:
+        `Move the most important rules to the top of ${file.path}, shorten or split low-priority content, ` +
+        `and increase OpenClaw's bootstrap limits if this file legitimately needs more room. ` +
+        kDoctorContextTruncationGuidance,
+      evidence: [
+        { type: "path", path: file.path },
+        {
+          type: "text",
+          text:
+            `Raw size: ${formatChars(file.rawChars)}. ` +
+            `Per-file limit: ${formatChars(bootstrapContext.bootstrapMaxChars)}.`,
+        },
+      ],
+      targetPaths: [{ path: file.path }],
+      fixPrompt:
+        `Reorganize ${file.path} so the most important instructions appear at the top and reduce unnecessary length. ` +
+        `Do not change unrelated behavior.`,
+      status: "open",
+    }));
+
+  const totalLimitedFiles = bootstrapContext.activeTruncatedFiles.filter(
+    (file) => file.reason === "total_limit" || file.reason === "file_and_total_limit",
+  );
+  if (totalLimitedFiles.length > 0) {
+    cards.unshift({
+      priority: "P0",
+      category: "project context",
+      title: "Project Context total bootstrap limit is truncating injected files",
+      summary:
+        `Injected workspace guidance needs ${formatChars(bootstrapContext.activeRawChars)} raw across active ` +
+        `Project Context files, exceeding the total bootstrap budget of ` +
+        `${formatChars(bootstrapContext.bootstrapTotalMaxChars)}.`,
+      recommendation:
+        `Reduce total Project Context size across injected guidance files, keep critical instructions near the top, ` +
+        `and raise OpenClaw's total bootstrap budget if the workspace legitimately needs more injected guidance. ` +
+        kDoctorContextTruncationGuidance,
+      evidence: totalLimitedFiles.map((file) => ({
+        type: "text",
+        text:
+          `${file.path}: raw ${formatChars(file.rawChars)}, injected ${formatChars(file.injectedChars)} ` +
+          `before the total limit stopped more content from being included.`,
+      })),
+      targetPaths: totalLimitedFiles.map((file) => ({ path: file.path })),
+      fixPrompt:
+        `Reduce the combined size of the affected Project Context files and keep the most important instructions near the top. ` +
+        `Only edit the files listed in the finding.`,
+      status: "open",
+    });
+  }
+
+  return cards;
+};
+
+module.exports = {
+  analyzeBootstrapContext,
+  buildBootstrapTruncationCards,
+  formatChars,
+  kDoctorBootstrapContextFiles,
+  kDoctorBootstrapExtraFiles,
+  kDoctorBootstrapMaxChars,
+  kDoctorBootstrapNearLimitRatio,
+  kDoctorBootstrapTotalMaxChars,
+  kDoctorContextTruncationGuidance,
+  kDoctorRootContextFiles,
+};

package/lib/server/doctor/prompt.js

@@ -1,6 +1,17 @@
+const {
+  kDoctorBootstrapExtraFiles,
+  kDoctorBootstrapMaxChars,
+  kDoctorBootstrapTotalMaxChars,
+  kDoctorContextTruncationGuidance,
+  kDoctorRootContextFiles,
+} = require("./bootstrap-context");
+
 const renderList = (items = []) =>
   items.length ? items.map((item) => `- ${item}`).join("\n") : "- (none)";
 
+const renderContextFileList = (files = []) =>
+  files.map((file) => `\`${file.path}\``).join(", ");
+
 const renderResolvedCards = (cards = []) => {
   if (!cards.length) return "";
   const lines = cards.map(
@@ -37,10 +48,15 @@ Important:
 - Return ONLY valid JSON. No markdown fences. No extra prose.
 
 OpenClaw context injection:
-- OpenClaw automatically injects a fixed set of named workspace files into the agent's context window ("Project Context") on every turn. The exact set is: \`AGENTS.md\`, \`SOUL.md\`, \`TOOLS.md\`, \`IDENTITY.md\`, \`USER.md\`, \`HEARTBEAT.md\`, and \`BOOTSTRAP.md\` (first-run only).
-- Only these specific files are auto-injected. Other \`.md\` files at the workspace root (e.g. INTERESTS.md, MEMORY.md, README.md) are NOT injected and must be explicitly read by the agent.
-- Do not flag auto-injected files as orphaned or unreferenced — they are loaded by the runtime, not by explicit file references in AGENTS.md.
-- Additionally, AlphaClaw injects bootstrap files from \`hooks/bootstrap/\` (e.g. AGENTS.md, TOOLS.md) as extra context on every turn.
+- OpenClaw automatically injects these workspace files into the agent's Project Context: ${renderContextFileList(
+    kDoctorRootContextFiles,
+  )}.
+- \`BOOTSTRAP.md\` is first-run only; the others above are injected on normal turns when present.
+- Additionally, AlphaClaw injects these extra bootstrap files on normal turns when present: ${renderContextFileList(
+    kDoctorBootstrapExtraFiles,
+  )}.
+- Large injected files are truncated per-file at ${kDoctorBootstrapMaxChars} chars by default, and total bootstrap injection across files is capped at ${kDoctorBootstrapTotalMaxChars} chars by default.
+- ${kDoctorContextTruncationGuidance}
 
 OpenClaw default context:
 - \`AGENTS.md\` is the workspace home file in the default OpenClaw template. It may intentionally include first-run instructions, session-startup guidance, memory conventions, safety rules, tool pointers, and optional behavioral guidance.

package/lib/server/doctor/service.js

@@ -1,5 +1,9 @@
 const fs = require("fs");
 const path = require("path");
+const {
+  analyzeBootstrapContext,
+  buildBootstrapTruncationCards,
+} = require("./bootstrap-context");
 const { buildDoctorPrompt } = require("./prompt");
 const { normalizeDoctorResult } = require("./normalize");
 const { calculateWorkspaceDelta, computeWorkspaceSnapshot } = require("./workspace-fingerprint");
@@ -137,6 +141,7 @@ const createDoctorService = ({
   };
 
   const buildStatus = () => {
+    const bootstrapContext = analyzeBootstrapContext({ workspaceRoot });
     const recentRuns = listDoctorRuns({ limit: 10 });
     const latestRun = recentRuns[0] || null;
     const latestCompletedRun =
@@ -179,6 +184,7 @@ const createDoctorService = ({
       lastRunAgeMs,
       needsInitialRun: !latestCompletedRun,
       stale,
+      bootstrapContext,
       changeSummary: {
         ...delta,
         hasBaseline: hasManifestBaseline,
@@ -245,10 +251,14 @@ const createDoctorService = ({
         console.error(`[doctor] run ${runId} stderr end`);
         throw error;
       }
-      captureEvidenceSnippets(normalizedResult.cards, workspaceRoot);
+      const bootstrapTruncationCards = buildBootstrapTruncationCards(
+        analyzeBootstrapContext({ workspaceRoot }),
+      );
+      const cards = [...bootstrapTruncationCards, ...normalizedResult.cards];
+      captureEvidenceSnippets(cards, workspaceRoot);
       insertDoctorCards({
         runId,
-        cards: normalizedResult.cards,
+        cards,
       });
       completeDoctorRun({
         id: runId,
@@ -342,7 +352,11 @@ const createDoctorService = ({
       throw new Error("Doctor import requires raw output");
     }
     const normalizedResult = normalizeDoctorResult(normalizedRawOutput);
-    captureEvidenceSnippets(normalizedResult.cards, workspaceRoot);
+    const bootstrapTruncationCards = buildBootstrapTruncationCards(
+      analyzeBootstrapContext({ workspaceRoot }),
+    );
+    const cards = [...bootstrapTruncationCards, ...normalizedResult.cards];
+    captureEvidenceSnippets(cards, workspaceRoot);
     const workspaceSnapshot = getCurrentWorkspaceSnapshot();
     const runId = createDoctorRun({
       status: kDoctorRunStatus.completed,
@@ -354,7 +368,7 @@ const createDoctorService = ({
     });
     insertDoctorCards({
       runId,
-      cards: normalizedResult.cards,
+      cards,
     });
     completeDoctorRun({
       id: runId,

package/lib/server.js

@@ -131,7 +131,7 @@ const app = express();
 app.set("trust proxy", kTrustProxyHops);
 app.use(["/webhook", "/hooks"], express.raw({ type: "*/*", limit: "5mb" }));
 app.use("/gmail-pubsub", express.raw({ type: "*/*", limit: "5mb" }));
-app.use(express.json());
+app.use(express.json({ limit: "5mb" }));
 
 const proxy = httpProxy.createProxyServer({
   target: GATEWAY_URL,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@chrysb/alphaclaw",
-  "version": "0.4.6-beta.7",
+  "version": "0.4.6-beta.8",
   "publishConfig": {
     "access": "public"
   },