@momenttttt/pi-zcode-memory 0.0.0-stage → 0.1.0

package/src/index-file.ts

@@ -0,0 +1,171 @@
+/**
+ * `MEMORY.md` 索引行的维护。
+ *
+ * 索引由模型维护，我们只在 `memory_write` 时插入/更新对应的一行：
+ *   `- [标题](file.md) — 一句话钩子`
+ *
+ * 写前比对 revision（`mtime:<截断毫秒>:size:<字节>`）；不一致就重读重试一次，再失败报错让
+ * 模型重试——**不**静默覆盖别人的改动。这里不是跨进程锁，只是把"读-改-写"的窗口缩到最小；
+ * 跨进程的并发靠 revision 前进被发现，下一次写读到新内容后自己继续。
+ */
+import { readFile, stat } from "node:fs/promises";
+import { join } from "node:path";
+
+import { atomicWriteFile } from "./atomic.ts";
+import { MemoryWriteError } from "./errors.ts";
+
+export const INDEX_FILENAME = "MEMORY.md";
+
+export interface IndexRevision {
+  /** `mtime:<截断毫秒>:size:<字节>`。 */
+  id: string;
+  mtimeMs: number;
+  sizeBytes: number;
+}
+
+export function revisionIdFromStat(stat: { mtimeMs: number; size: number }): string {
+  return `mtime:${Math.trunc(stat.mtimeMs)}:size:${stat.size}`;
+}
+
+export async function revisionOf(path: string): Promise<IndexRevision | undefined> {
+  try {
+    const info = await stat(path);
+    return { id: revisionIdFromStat(info), mtimeMs: info.mtimeMs, sizeBytes: info.size };
+  } catch (error) {
+    if (isNoEntryError(error)) return undefined;
+    throw error;
+  }
+}
+
+/** 两次 revision 是否一致；"之前不存在、现在也不存在"算一致。 */
+export function sameRevision(left: IndexRevision | undefined, right: IndexRevision | undefined): boolean {
+  if (left === undefined && right === undefined) return true;
+  if (left === undefined || right === undefined) return false;
+  return left.id === right.id;
+}
+
+export interface IndexLineInput {
+  /** 相对记忆目录的文件名（统一 `/`）。 */
+  filename: string;
+  title: string;
+  description: string;
+}
+
+export interface UpsertLineResult {
+  content: string;
+  action: "inserted" | "updated" | "unchanged";
+}
+
+function escapeRegExp(value: string): string {
+  return value.replace(/[.*+?^${}()|[\]\\]/gu, "\\$&");
+}
+
+function indexLineOf(input: IndexLineInput): string {
+  const hook = input.description.replace(/\s+/gu, " ").trim();
+  const link = `- [${input.title}](${input.filename})`;
+  return hook.length > 0 ? `${link} — ${hook}` : link;
+}
+
+/**
+ * 插入或更新一行；已存在等价行时返回 `unchanged`（不写盘）。
+ * 若同一文件已有重复行，保留第一行位置、删掉其余，顺带修掉历史重复。
+ */
+export function upsertMemoryIndexLine(content: string, input: IndexLineInput): UpsertLineResult {
+  const line = indexLineOf(input);
+  const linkPattern = new RegExp(`\\]\\(\\s*${escapeRegExp(input.filename)}\\s*\\)`, "u");
+  const lines = content.length === 0 ? [] : content.split("\n");
+  let replaced = false;
+  let removedDuplicate = false;
+  const next: string[] = [];
+  for (const existing of lines) {
+    if (linkPattern.test(existing)) {
+      if (!replaced) {
+        next.push(line);
+        replaced = true;
+      } else {
+        removedDuplicate = true;
+      }
+      continue;
+    }
+    next.push(existing);
+  }
+  if (replaced) {
+    const updated = next.join("\n");
+    if (updated === content && !removedDuplicate) return { content, action: "unchanged" };
+    return { content: ensureTrailingNewline(updated), action: "updated" };
+  }
+  const base = content.length === 0 ? "" : ensureTrailingNewline(content);
+  return { content: `${base}${line}\n`, action: "inserted" };
+}
+
+function ensureTrailingNewline(content: string): string {
+  return content.endsWith("\n") ? content : `${content}\n`;
+}
+
+async function readIndexOrEmpty(path: string): Promise<string> {
+  try {
+    return await readFile(path, "utf8");
+  } catch (error) {
+    if (isNoEntryError(error)) return "";
+    throw new MemoryWriteError("io", `Failed to read the index: ${path} (${describe(error)})`, "Retry later.");
+  }
+}
+
+export interface UpdateIndexOutcome {
+  indexPath: string;
+  action: "inserted" | "updated" | "unchanged";
+}
+
+export interface UpdateIndexOptions {
+  /** 测试注入：替换 revision 读取，用来确定性地演练"连续两次都读到改动"的失败路径。 */
+  revisionReader?: (path: string) => Promise<IndexRevision | undefined>;
+}
+
+/** 在 `<root>/MEMORY.md` 里插入/更新一行；revision 不一致时重读重试一次。 */
+export async function updateMemoryIndex(
+  root: string,
+  input: IndexLineInput,
+  options: UpdateIndexOptions = {},
+): Promise<UpdateIndexOutcome> {
+  const indexPath = join(root, INDEX_FILENAME);
+  const readRevision = options.revisionReader ?? revisionOf;
+  for (let attempt = 0; attempt < 2; attempt += 1) {
+    const before = await readRevision(indexPath);
+    const existing = await readIndexOrEmpty(indexPath);
+    const result = upsertMemoryIndexLine(existing, input);
+    if (result.action === "unchanged") {
+      return { indexPath, action: "unchanged" };
+    }
+    const now = await readRevision(indexPath);
+    if (!sameRevision(before, now)) {
+      // 读之后有人改过：这次结果作废，重读一次再试
+      continue;
+    }
+    await atomicWriteFile(indexPath, result.content).catch((error: unknown) => {
+      throw new MemoryWriteError(
+        "io",
+        `Failed to write the index: ${indexPath} (${describe(error)})`,
+        "Retry later.",
+      );
+    });
+    return { indexPath, action: result.action };
+  }
+  throw new MemoryWriteError(
+    "index_conflict",
+    `MEMORY.md was changed by another process after you read it (${indexPath}). The index was not written this time, so someone else's changes are not overwritten.`,
+    "Re-read the memory and retry this write.",
+  );
+}
+
+function isNoEntryError(error: unknown): boolean {
+  return (
+    typeof error === "object" &&
+    error !== null &&
+    "code" in error &&
+    (error as { code?: unknown }).code === "ENOENT"
+  );
+}
+
+function describe(error: unknown): string {
+  return error instanceof Error ? error.message : String(error);
+}

package/src/injection.ts

@@ -0,0 +1,82 @@
+/**
+ * 索引注入的纯决策部分：什么时候注入、会话里怎么重建"已注入"标记。
+ *
+ * 不 import pi；会话条目只按结构化字段读，便于 S1 单测。
+ */
+
+/** 会话标记条目的 customType（`pi.appendEntry` 写入，不进模型上下文）。 */
+export const INJECTED_ENTRY_TYPE = "zcode-memory/injected";
+
+/** 注入消息的 customType（`display: false` 的 custom 消息）。 */
+export const INDEX_MESSAGE_TYPE = "zcode-memory/index";
+
+/** 重建状态时只关心这些字段。 */
+export interface InjectionEntryLike {
+  type?: string;
+  customType?: string;
+  data?: unknown;
+  details?: unknown;
+}
+
+export interface InjectionDecisionInput {
+  messageType: "user" | "custom";
+  enabled: boolean;
+  injectIndex: boolean;
+  indexPresent: boolean;
+  /** 当前索引格式化后的 hash。 */
+  indexHash: string | undefined;
+  /** 当前会话里仍存活的注入 hash。 */
+  injectedHash: string | undefined;
+  /** `/memory reload` 置位。 */
+  force: boolean;
+}
+
+export type InjectionSkipReason =
+  | "disabled"
+  | "custom-run"
+  | "no-index"
+  | "already-injected";
+
+export type InjectionDecision =
+  | { inject: true; reason: "first" | "changed" | "reload" | "lost" }
+  | { inject: false; reason: InjectionSkipReason };
+
+export function decideInjection(input: InjectionDecisionInput): InjectionDecision {
+  if (!input.enabled || !input.injectIndex) return { inject: false, reason: "disabled" };
+  // `pi.sendMessage(..., { triggerTurn: true })` 起的运行不注入：那不是用户轮
+  if (input.messageType === "custom") return { inject: false, reason: "custom-run" };
+  if (!input.indexPresent || input.indexHash === undefined) return { inject: false, reason: "no-index" };
+  if (input.force) return { inject: true, reason: "reload" };
+  if (input.injectedHash === input.indexHash) return { inject: false, reason: "already-injected" };
+  if (input.injectedHash === undefined) return { inject: true, reason: "first" };
+  return { inject: true, reason: "changed" };
+}
+
+function hashOfMarkerData(data: unknown): string | undefined {
+  if (typeof data !== "object" || data === null) return undefined;
+  const value = (data as { indexHash?: unknown }).indexHash;
+  return typeof value === "string" && value.length > 0 ? value : undefined;
+}
+
+/**
+ * 从**当前上下文投影**的条目里重建"仍存活的注入 hash"。
+ *
+ * 传入的必须是 `buildSessionProjection()` 的条目（只包含压缩后的保留尾部）：注入消息被摘要掉
+ * 之后投影里就没有它了，调用方据此重新注入。标记条目与注入消息成对出现，缺一即视为丢失。
+ */
+export function rebuildInjectedHash(entries: readonly InjectionEntryLike[]): string | undefined {
+  const messageHashes = new Set<string>();
+  for (const entry of entries) {
+    if (entry.type !== "custom_message" || entry.customType !== INDEX_MESSAGE_TYPE) continue;
+    if (entry.details === undefined) continue;
+    const fromDetails = hashOfMarkerData(entry.details);
+    if (fromDetails !== undefined) messageHashes.add(fromDetails);
+  }
+  for (let index = entries.length - 1; index >= 0; index -= 1) {
+    const entry = entries[index]!;
+    if (entry.type !== "custom" || entry.customType !== INJECTED_ENTRY_TYPE) continue;
+    const hash = hashOfMarkerData(entry.data);
+    if (hash !== undefined && messageHashes.has(hash)) return hash;
+  }
+  return undefined;
+}

package/src/list.ts

@@ -0,0 +1,100 @@
+/**
+ * 扫记忆目录里的"事实文件"。
+ *
+ * 候选与排序都是对外承诺的一部分：递归扫 `.md`、排除索引自身；不递归进目录符号链接，
+ * 但指向文件的符号链接算候选；单个文件读不了只跳过它自己，不牵连其它条目；结果按 mtime
+ * 倒序（最近改动的排在前面）。不设条数上限——事实文件本来就不多，`memory_list` 给的是完整列表。
+ */
+import { closeSync, openSync, readdirSync, readSync, statSync } from "node:fs";
+import { basename, join, relative, sep } from "node:path";
+
+import { MEMORY_INDEX_FILENAME, type MemoryType } from "./paths.ts";
+import { parseMemoryFrontmatter } from "./frontmatter.ts";
+
+export interface MemoryListEntry {
+  /** 相对记忆目录的路径，统一 `/` 分隔。 */
+  filename: string;
+  name?: string;
+  description?: string;
+  type?: MemoryType;
+  mtimeMs: number;
+  /** frontmatter 坏了：记成"无描述条目"，不抛错。 */
+  malformed: boolean;
+}
+
+/** 单个事实文件最多读这么多字节来解析 frontmatter；防止误把大文件整份读进来。 */
+const FRONTMATTER_READ_BYTES = 64 * 1024;
+
+export function listMemoryFiles(root: string): MemoryListEntry[] {
+  const entries: MemoryListEntry[] = [];
+  collect(root, root, entries);
+  return entries.sort((left, right) => right.mtimeMs - left.mtimeMs);
+}
+
+function collect(root: string, directory: string, out: MemoryListEntry[]): void {
+  let dirents;
+  try {
+    dirents = readdirSync(directory, { withFileTypes: true });
+  } catch {
+    return;
+  }
+  for (const dirent of dirents) {
+    const path = join(directory, dirent.name);
+    if (dirent.isDirectory()) {
+      // 不递归进目录符号链接；指向文件的链接在下面单独判。
+      if (!dirent.isSymbolicLink()) collect(root, path, out);
+      continue;
+    }
+    let isFile = dirent.isFile();
+    if (dirent.isSymbolicLink()) {
+      try {
+        isFile = statSync(path).isFile();
+      } catch {
+        // 失效链接与"读不了的事实文件"一样，跳过即可
+        isFile = false;
+      }
+    }
+    if (!isFile) continue;
+    if (!isMemoryCandidate(dirent.name)) continue;
+    const entry = readEntry(root, path);
+    if (entry) out.push(entry);
+  }
+}
+
+function isMemoryCandidate(filename: string): boolean {
+  return filename.endsWith(".md") && basename(filename) !== MEMORY_INDEX_FILENAME;
+}
+
+function readEntry(root: string, path: string): MemoryListEntry | undefined {
+  let stat;
+  let head: string;
+  try {
+    stat = statSync(path);
+    head = readHead(path);
+  } catch {
+    // 单个文件读不了不影响其它条目
+    return undefined;
+  }
+  const frontmatter = parseMemoryFrontmatter(head);
+  const filename = relative(root, path).split(sep).join("/");
+  return {
+    filename,
+    mtimeMs: Math.trunc(stat.mtimeMs),
+    malformed: frontmatter.malformed,
+    ...(frontmatter.name === undefined ? {} : { name: frontmatter.name }),
+    ...(frontmatter.description === undefined ? {} : { description: frontmatter.description }),
+    ...(frontmatter.type === undefined ? {} : { type: frontmatter.type }),
+  };
+}
+
+/** 只读文件头这么多字节：frontmatter 只需前 30 行。 */
+function readHead(path: string): string {
+  const buffer = Buffer.allocUnsafe(FRONTMATTER_READ_BYTES);
+  const fd = openSync(path, "r");
+  try {
+    const bytesRead = readSync(fd, buffer, 0, buffer.length, 0);
+    return buffer.subarray(0, bytesRead).toString("utf8");
+  } finally {
+    closeSync(fd);
+  }
+}

package/src/paths.ts

@@ -0,0 +1,95 @@
+/**
+ * 共享记忆目录的路径算法（纯函数，不 import pi）。
+ *
+ * 规则：
+ *   - 存储根：`<home>/.zcode`，basename 已是 `cli` 就不再追加
+ *   - 项目目录：`memories/projects/<slug>-<hash16>/memory`
+ *   - hash 输入：工作区标识（远程/托管工作区才有），否则 `resolve(cwd)`；**仅 win32** 折叠大小写
+ *   - slug：小写、非 `[a-z0-9._-]` 换 `-`、去首尾 `-`、截 48、空则 `project`
+ *
+ * **`platform` 是参数而不是读 `process.platform`**：路径语义（分隔符、盘符、大小写）本身就是
+ * 这条算法的一部分，必须在**任何机器上**都能被单测覆盖两种语义——CI 跑在 Linux 上，
+ * 如果绑运行时平台，win32 分支（也就是用户实际在用的那套）永远测不到。
+ */
+import { createHash } from "node:crypto";
+import { posix, win32 } from "node:path";
+
+/** 记忆目录里索引文件的名字。 */
+export const MEMORY_INDEX_FILENAME = "MEMORY.md";
+
+/** 事实文件 frontmatter 允许的 `type`。 */
+export const MEMORY_TYPES = ["user", "feedback", "project", "reference"] as const;
+export type MemoryType = (typeof MEMORY_TYPES)[number];
+
+export interface MemoryDirInput {
+  /** 工作目录（会话的工作区路径）。 */
+  cwd: string;
+  /** CLI 存储根：`<home>/.zcode/cli`。 */
+  storageRoot: string;
+  /**
+   * 外部工作区标识（远程/托管工作区才有）。
+   * 独立 CLI 与桌面普通项目都是 undefined，此时 slug 取 basename、hash 取路径。
+   */
+  workspaceIdentity?: string;
+  /** 用哪套路径语义。默认当前平台；只有 win32 才折叠 keySource 的大小写。 */
+  platform?: NodeJS.Platform;
+}
+
+export interface ProjectDirParts {
+  /** 目录名里的 slug 段（identity 存在时固定为 `project`）。 */
+  slug: string;
+  /** 16 个 hex 字符。 */
+  hash: string;
+  /** `<slug>-<hash>`。 */
+  dirName: string;
+}
+
+/** 按平台挑 path 实现：win32 一套，其余走 POSIX。 */
+export function pathImpl(platform: NodeJS.Platform | undefined) {
+  return (platform ?? process.platform) === "win32" ? win32 : posix;
+}
+
+/** 存储根归一化：basename 已是 `cli` 就不再追加。 */
+export function ensureCliStorageRoot(storageRoot: string, platform?: NodeJS.Platform): string {
+  const impl = pathImpl(platform);
+  return impl.basename(storageRoot) === "cli" ? storageRoot : impl.join(storageRoot, "cli");
+}
+
+/** 由 home 推导存储根：`<home>/.zcode` 再归一化。 */
+export function resolveZcodeStorageRoot(homeDir: string, platform?: NodeJS.Platform): string {
+  const impl = pathImpl(platform);
+  return ensureCliStorageRoot(impl.join(homeDir, ".zcode"), platform);
+}
+
+/** slug 清洗：小写 → 非 `[a-z0-9._-]` 换 `-` → 去首尾 `-` → 截 48 → 空则 `project`。 */
+export function sanitizeProjectSlug(value: string): string {
+  const slug = value
+    .toLowerCase()
+    .replace(/[^a-z0-9._-]+/g, "-")
+    .replace(/^-+|-+$/g, "")
+    .slice(0, 48);
+  return slug.length > 0 ? slug : "project";
+}
+
+/** 目录名（`<slug>-<hash16>`）与它的输入。 */
+export function computeProjectDirParts(input: MemoryDirInput): ProjectDirParts {
+  const impl = pathImpl(input.platform);
+  const identity = input.workspaceIdentity?.trim();
+  const resolvedCwd = impl.resolve(input.cwd);
+  const keySource =
+    identity || ((input.platform ?? process.platform) === "win32" ? resolvedCwd.toLowerCase() : resolvedCwd);
+  const hash = createHash("sha256").update(keySource).digest("hex").slice(0, 16);
+  const slug = identity ? "project" : sanitizeProjectSlug(impl.basename(resolvedCwd) || "project");
+  return { slug, hash, dirName: `${slug}-${hash}` };
+}
+
+/** `memories/projects/` 根：三级回退第 3 步扫描的目录。 */
+export function projectsRootOf(storageRoot: string, platform?: NodeJS.Platform): string {
+  return pathImpl(platform).join(storageRoot, "memories", "projects");
+}
+
+/** `<storageRoot>/memories/projects/<slug>-<hash>/memory`。 */
+export function computeMemoryDir(input: MemoryDirInput): string {
+  const parts = computeProjectDirParts(input);
+  return pathImpl(input.platform).join(projectsRootOf(input.storageRoot, input.platform), parts.dirName, "memory");
+}

package/src/read.ts

@@ -0,0 +1,175 @@
+/**
+ * `memory_read` 的定位与读取。
+ *
+ * - 定位：按 frontmatter `name`、或按文件名（相对记忆目录，支持子目录）精确匹配；
+ *   多处命中时报错而不是猜一个。
+ * - 正文上限：先取前 200 行，再按 4096 字节截断到完整行的边界；任一超限都算截断。
+ *   这两个数就是一条记忆在会话里实际可用的量——读到上限的内容不该被当成全文。
+ */
+import { existsSync, readFileSync, statSync } from "node:fs";
+import { basename, isAbsolute, relative, resolve } from "node:path";
+
+import { hashMemoryContent } from "./bridge.ts";
+import { normalizeMemoryText, parseMemoryDocument, type MemoryFrontmatter } from "./frontmatter.ts";
+import { listMemoryFiles } from "./list.ts";
+
+export const MEMORY_BODY_LINE_LIMIT = 200;
+export const MEMORY_BODY_BYTE_LIMIT = 4096;
+
+export interface LocatedMemory {
+  /** 相对记忆目录的路径，统一 `/` 分隔。 */
+  filename: string;
+  absolutePath: string;
+  sizeBytes: number;
+  mtimeMs: number;
+  /** sha256(磁盘上的原始 utf8 文本)，与 read-guard 的 `hashContent` 同构。 */
+  contentHash: string;
+  frontmatter: MemoryFrontmatter;
+  body: string;
+}
+
+export interface LocateError {
+  code: "not_found" | "ambiguous" | "outside_root" | "unreadable";
+  message: string;
+}
+
+export type LocateResult = { ok: true; value: LocatedMemory } | { ok: false; error: LocateError };
+
+/** 把引用折成记忆目录内的绝对路径；越界返回 undefined。 */
+export function resolveUnderRoot(root: string, reference: string): string | undefined {
+  const cleaned = reference.trim().replace(/\\/gu, "/").replace(/^(?:\.\/)+/u, "");
+  if (cleaned.length === 0) return undefined;
+  if (cleaned.startsWith("/") || /^[A-Za-z]:/u.test(cleaned)) return undefined;
+  const absolute = resolve(root, cleaned);
+  const rel = relative(root, absolute);
+  if (rel.length === 0 || rel.startsWith("..") || isAbsolute(rel)) return undefined;
+  return absolute;
+}
+
+function isFile(path: string): boolean {
+  try {
+    return statSync(path).isFile();
+  } catch {
+    return false;
+  }
+}
+
+export function locateMemory(root: string, reference: string): LocateResult {
+  const ref = reference.trim().replace(/\\/gu, "/").replace(/^(?:\.\/)+/u, "");
+  if (ref.length === 0) {
+    return { ok: false, error: { code: "not_found", message: "The reference is empty: pass the memory's name or filename." } };
+  }
+
+  // 1) 直接当相对路径试：`foo.md`、`sub/foo.md`，以及（允许的）MEMORY.md
+  const direct = resolveUnderRoot(root, ref);
+  if (direct !== undefined && isFile(direct)) {
+    const located = readLocated(root, direct);
+    if (located.ok) return located;
+  }
+  // 2) 没有 `.md` 后缀时补一次
+  if (!ref.endsWith(".md")) {
+    const withSuffix = resolveUnderRoot(root, `${ref}.md`);
+    if (withSuffix !== undefined && isFile(withSuffix)) {
+      const located = readLocated(root, withSuffix);
+      if (located.ok) return located;
+    }
+  }
+
+  // 3) 扫目录按 name / 文件名匹配
+  const matches = new Map<string, string>();
+  for (const entry of listMemoryFiles(root)) {
+    const withoutExtension = entry.filename.replace(/\.md$/iu, "");
+    const filenameBase = basename(withoutExtension);
+    if (entry.name === ref || entry.filename === ref || withoutExtension === ref || filenameBase === ref) {
+      matches.set(entry.filename, entry.filename);
+    }
+  }
+  if (matches.size === 1) {
+    const filename = [...matches.keys()][0]!;
+    const absolute = resolve(root, filename);
+    const located = readLocated(root, absolute);
+    if (located.ok) return located;
+  }
+  if (matches.size > 1) {
+    return {
+      ok: false,
+      error: {
+        code: "ambiguous",
+        message: `"${reference}" matches more than one memory; pass the filename instead: ${[...matches.keys()].join(", ")}`,
+      },
+    };
+  }
+  return {
+    ok: false,
+    error: {
+      code: "not_found",
+      message: `No memory "${reference}" in the memory directory. Use memory_list first to see which memories exist.`,
+    },
+  };
+}
+
+function readLocated(root: string, absolutePath: string): LocateResult {
+  let stat;
+  let content: string;
+  try {
+    stat = statSync(absolutePath);
+    content = readFileSync(absolutePath, "utf8");
+  } catch (error) {
+    return {
+      ok: false,
+      error: {
+        code: "unreadable",
+        message: `Read failed: ${absolutePath} (${error instanceof Error ? error.message : String(error)})`,
+      },
+    };
+  }
+  const normalized = normalizeMemoryText(content);
+  const document = parseMemoryDocument(normalized);
+  return {
+    ok: true,
+    value: {
+      filename: relative(root, absolutePath).split("\\").join("/"),
+      absolutePath,
+      sizeBytes: stat.size,
+      mtimeMs: Math.trunc(stat.mtimeMs),
+      contentHash: hashMemoryContent(content),
+      frontmatter: document.frontmatter,
+      body: document.body,
+    },
+  };
+}
+
+export interface TruncatedBody {
+  text: string;
+  truncated: boolean;
+  /** 截断原因，用于提示文案；未截断时 undefined。 */
+  reason?: "lines" | "bytes" | "both";
+}
+
+export function truncateMemoryBody(body: string): TruncatedBody {
+  const lines = body === "" ? [""] : body.split("\n");
+  const lineTruncated = lines.length > MEMORY_BODY_LINE_LIMIT;
+  const lineLimited = lineTruncated ? lines.slice(0, MEMORY_BODY_LINE_LIMIT).join("\n") : body;
+
+  const selected: string[] = [];
+  let selectedBytes = 0;
+  let byteTruncated = false;
+  for (const line of lineLimited.split("\n")) {
+    const separatorBytes = selected.length > 0 ? 1 : 0;
+    const nextBytes = selectedBytes + separatorBytes + Buffer.byteLength(line, "utf8");
+    if (nextBytes > MEMORY_BODY_BYTE_LIMIT) {
+      byteTruncated = true;
+      break;
+    }
+    selected.push(line);
+    selectedBytes = nextBytes;
+  }
+
+  const reason: TruncatedBody["reason"] =
+    lineTruncated && byteTruncated ? "both" : lineTruncated ? "lines" : byteTruncated ? "bytes" : undefined;
+  return {
+    text: selected.join("\n"),
+    truncated: lineTruncated || byteTruncated,
+    ...(reason === undefined ? {} : { reason }),
+  };
+}