Vendor OpenClaw source as Adolf fork baseline

Adolf is a fork/vendored clone of github.com/openclaw/openclaw (v2026.6.11),
free to diverge. Tree copied sans upstream .git; upstream remote added for
future syncs. Node pinned to 24 (.nvmrc); engines already require >=22.19.
Preserves docs/ARCHITECTURE.md.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01LeqyaxJF2nbRXJtae2kNB2

scripts/e2e/lib/session-log-mentions.ts

@@ -0,0 +1,152 @@
+// Session Log Mentions script supports OpenClaw repository automation.
+import fs from "node:fs/promises";
+import path from "node:path";
+import { readPositiveIntEnv } from "./env-limits.mjs";
+
+export type SessionLogMentionLimits = {
+  fileMaxBytes: number;
+  totalMaxBytes: number;
+};
+
+export type SessionLogNeedles = Record<string, string>;
+
+const DEFAULT_FILE_MAX_BYTES = 4 * 1024 * 1024;
+const DEFAULT_TOTAL_MAX_BYTES = 16 * 1024 * 1024;
+
+export function readSessionLogMentionLimits(
+  env: NodeJS.ProcessEnv = process.env,
+): SessionLogMentionLimits {
+  return {
+    fileMaxBytes: readPositiveIntEnv(
+      "OPENCLAW_SESSION_LOG_MENTION_FILE_MAX_BYTES",
+      DEFAULT_FILE_MAX_BYTES,
+      env,
+    ),
+    totalMaxBytes: readPositiveIntEnv(
+      "OPENCLAW_SESSION_LOG_MENTION_TOTAL_MAX_BYTES",
+      DEFAULT_TOTAL_MAX_BYTES,
+      env,
+    ),
+  };
+}
+
+function taggedError(message: string, code: string) {
+  return Object.assign(new Error(message), { code });
+}
+
+function countOccurrences(haystack: string, needle: string): number {
+  if (!needle) {
+    return 0;
+  }
+  let count = 0;
+  let offset = 0;
+  for (;;) {
+    const next = haystack.indexOf(needle, offset);
+    if (next < 0) {
+      return count;
+    }
+    count += 1;
+    offset = next + needle.length;
+  }
+}
+
+function createCounts(needles: SessionLogNeedles): Record<string, number> {
+  return Object.fromEntries(Object.keys(needles).map((key) => [key, 0]));
+}
+
+function recordRole(record: unknown): string | undefined {
+  if (!record || typeof record !== "object") {
+    return undefined;
+  }
+  const candidate = record as { message?: unknown; role?: unknown };
+  if (typeof candidate.role === "string") {
+    return candidate.role;
+  }
+  if (!candidate.message || typeof candidate.message !== "object") {
+    return undefined;
+  }
+  const message = candidate.message as { role?: unknown };
+  return typeof message.role === "string" ? message.role : undefined;
+}
+
+function shouldScanSessionLogLine(line: string): boolean {
+  const trimmed = line.trim();
+  if (!trimmed) {
+    return false;
+  }
+  try {
+    return recordRole(JSON.parse(trimmed)) !== "user";
+  } catch {
+    return true;
+  }
+}
+
+function assertWithinLimit(params: {
+  byteCount: number;
+  filePath?: string;
+  label: string;
+  limit: number;
+}) {
+  if (params.byteCount <= params.limit) {
+    return;
+  }
+  const source = params.filePath ? ` ${params.filePath}` : "";
+  throw taggedError(
+    `session log mention scan exceeded ${params.label} limit${source}: ${params.byteCount} > ${params.limit}`,
+    "ETOOBIG",
+  );
+}
+
+export async function countSessionLogMentions(params: {
+  limits?: SessionLogMentionLimits;
+  needles: SessionLogNeedles;
+  sessionsDir: string;
+}): Promise<Record<string, number>> {
+  const limits = params.limits ?? readSessionLogMentionLimits();
+  const counts = createCounts(params.needles);
+  let files: string[];
+  try {
+    files = await fs.readdir(params.sessionsDir);
+  } catch {
+    return counts;
+  }
+
+  let totalBytes = 0;
+  for (const file of files.filter((candidate) => candidate.endsWith(".jsonl")).toSorted()) {
+    const filePath = path.join(params.sessionsDir, file);
+    const stat = await fs.stat(filePath).catch(() => null);
+    if (!stat?.isFile()) {
+      continue;
+    }
+    assertWithinLimit({
+      byteCount: stat.size,
+      filePath,
+      label: "per-file",
+      limit: limits.fileMaxBytes,
+    });
+    totalBytes += stat.size;
+    assertWithinLimit({
+      byteCount: totalBytes,
+      label: "total",
+      limit: limits.totalMaxBytes,
+    });
+
+    const raw = await fs.readFile(filePath, "utf8").catch(() => "");
+    const actualBytes = Buffer.byteLength(raw, "utf8");
+    assertWithinLimit({
+      byteCount: actualBytes,
+      filePath,
+      label: "per-file",
+      limit: limits.fileMaxBytes,
+    });
+    for (const line of raw.split(/\r?\n/u)) {
+      if (!shouldScanSessionLogLine(line)) {
+        continue;
+      }
+      for (const [key, needle] of Object.entries(params.needles)) {
+        counts[key] += countOccurrences(line, needle);
+      }
+    }
+  }
+  return counts;
+}