dsh-plugin-lrc 0.2.0

package/package.json

@@ -0,0 +1,64 @@
+{
+  "name": "dsh-plugin-lrc",
+  "version": "0.2.0",
+  "description": "把 LRC 的结构化长期记忆接进 DeepSeek Harness：边聊边沉淀、按需召回、可纠错，让上下文不再需要频繁压缩",
+  "type": "module",
+  "main": "dist/index.js",
+  "files": [
+    "dist/index.js",
+    "src",
+    "cordis.patch.yml",
+    "README.md",
+    "LICENSE"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/zhibaiYingChuan/dsh-plugin-lrc.git"
+  },
+  "homepage": "https://github.com/zhibaiYingChuan/dsh-plugin-lrc#readme",
+  "bugs": {
+    "url": "https://github.com/zhibaiYingChuan/dsh-plugin-lrc/issues"
+  },
+  "scripts": {
+    "build": "esbuild src/index.ts --bundle --platform=node --format=esm --target=node20 --charset=utf8 --external:@deepseek-ai/* --outfile=dist/index.js",
+    "smoke": "node scripts/smoke.ts",
+    "e2e": "node scripts/e2e-offload.ts",
+    "e2e:runtime": "node scripts/e2e-runtime.ts",
+    "e2e:host": "node scripts/e2e-host-payload.ts",
+    "e2e:filter": "node scripts/e2e-filter.ts",
+    "e2e:trim": "node scripts/e2e-trim.ts",
+    "e2e:handoff": "node scripts/e2e-handoff.ts",
+    "e2e:apply": "node --import ./scripts/register-loader.mjs scripts/e2e-apply.ts",
+    "e2e:governor": "node scripts/e2e-governor.ts",
+    "e2e:budget": "node scripts/e2e-budget.ts",
+    "e2e:turn": "node --import ./scripts/register-loader.mjs scripts/e2e-turn.ts",
+    "e2e:invariant": "node scripts/e2e-invariant.ts",
+    "e2e:profile": "node scripts/e2e-profile.ts",
+    "test": "node scripts/smoke.ts && node scripts/e2e-offload.ts && node scripts/e2e-runtime.ts && node scripts/e2e-host-payload.ts && node scripts/e2e-filter.ts && node scripts/e2e-trim.ts && node scripts/e2e-host-surface.ts && node scripts/e2e-handoff.ts && node scripts/e2e-governor.ts && node scripts/e2e-budget.ts && node scripts/e2e-profile.ts && node scripts/e2e-invariant.ts && node --import ./scripts/register-loader.mjs scripts/e2e-apply.ts && node --import ./scripts/register-loader.mjs scripts/e2e-turn.ts"
+  },
+  "keywords": [
+    "dsh-plugin",
+    "deepseek-harness",
+    "memory",
+    "context",
+    "compaction"
+  ],
+  "dsh": {
+    "bundle": {
+      "patch": "./cordis.patch.yml"
+    }
+  },
+  "peerDependencies": {
+    "@deepseek-ai/cordis": "*",
+    "@deepseek-ai/dsh-tools": "*",
+    "@deepseek-ai/schemastery": "*"
+  },
+  "engines": {
+    "node": ">=20",
+    "dsh": ">=0.2.0-rc.1 <0.3.0-0"
+  },
+  "license": "MIT",
+  "devDependencies": {
+    "esbuild": "^0.28.2"
+  }
+}

package/src/budget.ts

@@ -0,0 +1,195 @@
+/**
+ * 统一预算：把散落的魔法数字收敛成「按模型窗口比例推导」。
+ *
+ * ## 为什么需要
+ *
+ * 之前 `trimMinTokens=60000` 是按某个默认模型拍的，换到 1M 窗口就变成 6%，
+ * 33K 的会话永远不触发；`pruneResultThreshold=8192` 同理。
+ * 阈值应该跟着模型窗口走，而不是写死。
+ *
+ * ## 推导规则
+ *
+ * ```
+ * trimMinTokens        = clamp(window * trimRatio,  8000, 200000)
+ * pruneResultThreshold = clamp(window * pruneRatio, 2048, 8192)
+ * ```
+ *
+ * 窗口未知时退回配置里的绝对值，绝不因为探测失败而停摆。
+ */
+
+/** 预算配置（来自插件配置）。 */
+export interface BudgetConfig {
+  /** 显式指定模型窗口；0 表示自动探测 */
+  contextWindowTokens: number;
+  /** 裁剪阈值占窗口的比例 */
+  trimRatio: number;
+  /** 工具输出剪枝阈值占窗口的比例 */
+  pruneRatio: number;
+  /** 窗口未知时的裁剪阈值（绝对值） */
+  trimMinTokens: number;
+  /** 窗口未知时的剪枝阈值（绝对值） */
+  pruneResultThreshold: number;
+}
+
+/** 解析后的预算。 */
+export interface ResolvedBudget {
+  /** 模型窗口；0 表示未知 */
+  windowTokens: number;
+  trimMinTokens: number;
+  pruneResultThreshold: number;
+  /** auto = 从模型探测；configured = 显式配置；fallback = 探测失败用绝对值 */
+  source: 'auto' | 'configured' | 'fallback';
+  /** 探测到的模型名（诊断用；fallback 时为空） */
+  model?: string;
+  /** 降级原因（诊断用） */
+  note?: string;
+}
+
+/** 窗口的合理下限：低于 8K 视为探测异常。 */
+const MIN_SANE_WINDOW = 8_192;
+/**
+ * 可信窗口上限（不含）。
+ *
+ * 探测值达到这个数就**不再当作比例基线**：实测宿主对未知模型会返回
+ * 1,000,000 这个哨兵值，而真实会话只有 80K —— 按 1M 推导出的
+ * `trim=30000`（3%）看似能用，但分母是错的，任何比例缩放都失去意义。
+ *
+ * 降级后的绝对值（30000/4096）是实测可用的保守档，方向安全：宁可早裁，不可溢出。
+ *
+ * ⚠️ 2026-11-08 实测修正：`deepseek-v4.1-flash` 的 contextWindow 确实是
+ * 1,048,576，探测到的 1,000,000 是**真实窗口**而非哨兵值。也就是说这条规则
+ * 会把「真实 1M 窗口」误判为「未知模型」。当前不造成危害——降级值 30000
+ * 恰好落在成本 U 形曲线的低成本区（最优点约 53K，仅差 11%），且方向偏保守。
+ * 若将来要按真实窗口推导，应显式配置 `contextWindowTokens`，而不是依赖探测。
+ */
+const MAX_TRUSTED_WINDOW = 1_000_000;
+
+function clamp(value: number, min: number, max: number): number {
+  return Math.min(max, Math.max(min, value));
+}
+
+function safeGet(ctx: unknown, name: string): unknown {
+  try {
+    return (ctx as { get?: (n: string) => unknown })?.get?.(name);
+  } catch {
+    return undefined;
+  }
+}
+
+/** 从会话的请求头里取当前路由的 provider/model。 */
+function routedTarget(session: unknown): { provider: string; model: string } | undefined {
+  const config = (session as { requestHeader?: () => { config?: { provider?: unknown; model?: unknown } } })
+    ?.requestHeader?.()?.config;
+  const provider = config?.provider;
+  const model = config?.model;
+  if (typeof provider !== 'string' || typeof model !== 'string') return undefined;
+  if (provider.length === 0 || model.length === 0) return undefined;
+  return { provider, model };
+}
+
+/**
+ * 解析预算。
+ *
+ * 永不抛错：探测失败一律退回配置绝对值。
+ *
+ * @param deps - 宿主 ctx、agent、预算配置
+ * @returns 解析后的预算
+ */
+export async function resolveBudget(deps: {
+  ctx: unknown;
+  agent: unknown;
+  config: BudgetConfig;
+}): Promise<ResolvedBudget> {
+  const { ctx, agent, config } = deps;
+
+  // 显式配置优先
+  if (config.contextWindowTokens > 0) {
+    return derive(config.contextWindowTokens, config, 'configured');
+  }
+
+  // 自动探测：llm.resolveModelInfo(provider, model)
+  const session = (agent as { session?: unknown })?.session;
+  const target = routedTarget(session);
+  if (target === undefined) {
+    return {
+      windowTokens: 0,
+      trimMinTokens: config.trimMinTokens,
+      pruneResultThreshold: config.pruneResultThreshold,
+      source: 'fallback',
+    };
+  }
+
+  const llm = safeGet(ctx, 'llm') as
+    | {
+        resolveModelInfo?: (
+          provider: string,
+          model: string,
+        ) => Promise<{ context?: { contextWindow?: unknown } }>;
+      }
+    | undefined;
+  if (typeof llm?.resolveModelInfo !== 'function') {
+    return {
+      windowTokens: 0,
+      trimMinTokens: config.trimMinTokens,
+      pruneResultThreshold: config.pruneResultThreshold,
+      source: 'fallback',
+    };
+  }
+
+  try {
+    const info = await llm.resolveModelInfo(target.provider, target.model);
+    const window = info?.context?.contextWindow;
+    if (typeof window === 'number' && Number.isFinite(window) && window > 0) {
+      // 探测值达到上限 → 视为「未知模型的哨兵值」，退回绝对值。
+      // 不能钳到 1M 继续用：分母错了，所有按比例推导的阈值都失去意义。
+      if (window >= MAX_TRUSTED_WINDOW) {
+        return {
+          windowTokens: 0,
+          trimMinTokens: config.trimMinTokens,
+          pruneResultThreshold: config.pruneResultThreshold,
+          source: 'fallback',
+          model: target.model,
+          // 提示可显式配置：哨兵值无法区分「真实 1M 窗口」与「未知模型」，
+          // 若确知模型窗口，配置 contextWindowTokens 即可按真实窗口推导阈值。
+          note: `probe=${window} 达到可信上限，视为未知模型；如确知窗口请显式配置 contextWindowTokens`,
+        };
+      }
+      // 过小的探测值钳到下限，避免 trim 阈值等于整个窗口
+      const sane = Math.max(MIN_SANE_WINDOW, window);
+      return { ...derive(sane, config, 'auto'), model: target.model };
+    }
+  } catch {
+    // 探测失败：退回绝对值
+  }
+
+  return {
+    windowTokens: 0,
+    trimMinTokens: config.trimMinTokens,
+    pruneResultThreshold: config.pruneResultThreshold,
+    source: 'fallback',
+  };
+}
+
+function derive(
+  windowTokens: number,
+  config: BudgetConfig,
+  source: 'auto' | 'configured',
+): ResolvedBudget {
+  return {
+    windowTokens,
+    trimMinTokens: clamp(Math.floor(windowTokens * config.trimRatio), 8000, 200000),
+    pruneResultThreshold: clamp(Math.floor(windowTokens * config.pruneRatio), 2048, 8192),
+    source,
+  };
+}
+
+/** 一行可读摘要（启动日志用）。 */
+export function formatBudget(budget: ResolvedBudget): string {
+  const window = budget.windowTokens > 0 ? `${budget.windowTokens} tokens` : '未知';
+  const model = budget.model === undefined ? '' : ` model=${budget.model}`;
+  const note = budget.note === undefined ? '' : ` note=${budget.note}`;
+  return (
+    `[lrc][budget] 窗口=${window}（${budget.source}）${model}${note}` +
+    ` trim=${budget.trimMinTokens} tokens prune=${budget.pruneResultThreshold} 字符`
+  );
+}

package/src/capabilities.ts

@@ -0,0 +1,185 @@
+/**
+ * 能力矩阵：启动时探测一次，之后所有路径按矩阵决定「做不做」。
+ *
+ * ## 为什么需要
+ *
+ * 前几轮故障的共同形态是「调用时才发现不可用」：
+ * - `session.events` 在某些版本不存在 → trim 静默失效
+ * - `surfaceOp` 字段名 `start/end` vs `startSeq/endSeq` → 剪枝 100% 失败
+ * - `engine.ctx.tokenMeter` 直接属性访问 → inject 崩溃
+ *
+ * 把探测集中到一处，好处是：失败只发生一次、日志只打一次、
+ * 调用方拿到的是明确的「可用/不可用」而不是运行时异常。
+ *
+ * ## 探测原则
+ *
+ * 只读、不写、不抛错。任何一项探测失败都记为「不可用 + 原因」，
+ * 绝不让探测本身掀翻插件。
+ */
+import { resolveSessionEvents } from './context-trim.ts';
+
+/** 单项能力。 */
+export interface Capability {
+  available: boolean;
+  /** 诊断细节：不可用时说明原因，可用时说明来源 */
+  detail: string;
+}
+
+/** surfaceOp 的字段名形状（不同 DSH 版本不一致）。 */
+export type SurfaceOpShape = 'start-end' | 'startSeq-endSeq' | 'unknown';
+
+/** 一次探测得到的完整能力矩阵。 */
+export interface CapabilityMatrix {
+  /** 压缩引擎（路径 1 依赖） */
+  compaction: Capability;
+  /** token 计量（路径 1 的阈值判断依赖） */
+  tokenMeter: Capability;
+  /** 官方工具输出剪枝器（路径 2 依赖） */
+  toolResultPruner: Capability;
+  /** 会话存储（路径 6 兜底依赖） */
+  sessions: Capability;
+  /** agent 工厂（路径 6 首选依赖） */
+  agents: Capability;
+  /** 系统提示注册（快照注入依赖） */
+  systemPrompt: Capability;
+  /** replace 事件的字段名形状 */
+  surfaceOpShape: SurfaceOpShape;
+  /** 探测时间 */
+  probedAt: number;
+}
+
+function safeGet(ctx: unknown, name: string): unknown {
+  try {
+    return (ctx as { get?: (n: string) => unknown })?.get?.(name);
+  } catch {
+    return undefined;
+  }
+}
+
+function hasFn(value: unknown, name: string): boolean {
+  return typeof (value as Record<string, unknown> | undefined)?.[name] === 'function';
+}
+
+/** 从引擎的 ctx 取服务（引擎 ctx 在 preset 隔离组内，宿主层可能拿不到）。 */
+function fromEngine(engine: unknown, name: string): unknown {
+  try {
+    return (engine as { ctx?: { get?: (n: string) => unknown } } | undefined)?.ctx?.get?.(name);
+  } catch {
+    return undefined;
+  }
+}
+
+/**
+ * 探测 surfaceOp 的字段名形状。
+ *
+ * 扫描会话里已有的 replace 事件：有 `start` 就是 start-end，
+ * 有 `startSeq` 就是 startSeq-endSeq。都没有则 unknown（调用方两种都试）。
+ */
+export function probeSurfaceOpShape(session: unknown): SurfaceOpShape {
+  const events = resolveSessionEvents(session);
+  if (events === undefined) return 'unknown';
+  for (const raw of events) {
+    const op = (raw as { surfaceOp?: unknown })?.surfaceOp;
+    if (op === null || typeof op !== 'object') continue;
+    const record = op as Record<string, unknown>;
+    if (record['op'] !== 'replace') continue;
+    if (Object.hasOwn(record, 'start') && Object.hasOwn(record, 'end')) return 'start-end';
+    if (Object.hasOwn(record, 'startSeq') && Object.hasOwn(record, 'endSeq')) return 'startSeq-endSeq';
+  }
+  return 'unknown';
+}
+
+/**
+ * 探测一次完整能力矩阵。
+ *
+ * @param ctx - 宿主上下文
+ * @param agent - 当前 agent（用于穿透 preset 隔离）
+ * @returns 能力矩阵（永不抛错）
+ */
+export function probeCapabilities(ctx: unknown, agent: unknown): CapabilityMatrix {
+  const presets = safeGet(ctx, 'agentPresets') as
+    | { serviceFor?: (a: unknown, n: string) => unknown }
+    | undefined;
+
+  // 压缩引擎
+  let engine: unknown;
+  let engineError = '';
+  try {
+    engine = presets?.serviceFor?.(agent, 'compaction');
+  } catch (error) {
+    engineError = error instanceof Error ? error.message : String(error);
+  }
+  const compaction: Capability = {
+    available: hasFn(engine, 'compactRegion'),
+    detail:
+      engineError !== ''
+        ? `serviceFor 抛错：${engineError}`
+        : engine === undefined
+          ? 'serviceFor 返回 undefined'
+          : `引擎=${(engine as { constructor?: { name?: string } })?.constructor?.name ?? 'unknown'}`,
+  };
+
+  // token 计量：引擎 ctx 优先，宿主层兜底
+  const meter = fromEngine(engine, 'tokenMeter') ?? safeGet(ctx, 'tokenMeter');
+  const tokenMeter: Capability = {
+    available: hasFn(meter, 'measure'),
+    detail: meter === undefined ? 'tokenMeter 不可达' : 'measure 可用',
+  };
+
+  // 官方剪枝器：三条路
+  const pruner =
+    safeGet(ctx, 'toolResultPruner') ??
+    (() => {
+      try {
+        return presets?.serviceFor?.(agent, 'toolResultPruner');
+      } catch {
+        return undefined;
+      }
+    })() ??
+    fromEngine(engine, 'toolResultPruner');
+  const toolResultPruner: Capability = {
+    available: hasFn(pruner, 'pruneSession'),
+    detail: pruner === undefined ? 'toolResultPruner 不可达' : 'pruneSession 可用',
+  };
+
+  const sessions = safeGet(ctx, 'sessions');
+  const agents = safeGet(ctx, 'agents');
+  const systemPrompt = safeGet(ctx, 'systemPrompt');
+
+  return {
+    compaction,
+    tokenMeter,
+    toolResultPruner,
+    sessions: {
+      available: hasFn(sessions, 'create'),
+      detail: sessions === undefined ? 'sessions 不可达' : 'create 可用',
+    },
+    agents: {
+      available: hasFn(agents, 'create'),
+      detail: agents === undefined ? 'agents 不可达' : 'create 可用',
+    },
+    systemPrompt: {
+      available: hasFn(systemPrompt, 'section') || hasFn(systemPrompt, 'context'),
+      detail: systemPrompt === undefined ? 'systemPrompt 不可达' : 'section/context 可用',
+    },
+    surfaceOpShape: probeSurfaceOpShape((agent as { session?: unknown })?.session),
+    probedAt: Date.now(),
+  };
+}
+
+/** 把能力矩阵压成一行行日志（启动时打一次）。 */
+export function formatCapabilities(matrix: CapabilityMatrix): string[] {
+  const rows: Array<[string, Capability]> = [
+    ['compaction', matrix.compaction],
+    ['tokenMeter', matrix.tokenMeter],
+    ['toolResultPruner', matrix.toolResultPruner],
+    ['sessions', matrix.sessions],
+    ['agents', matrix.agents],
+    ['systemPrompt', matrix.systemPrompt],
+  ];
+  const lines = rows.map(
+    ([name, cap]) => `[lrc][cap] ${cap.available ? '可用  ' : '不可用'} ${name} | ${cap.detail}`,
+  );
+  lines.push(`[lrc][cap] surfaceOp 形状：${matrix.surfaceOpShape}`);
+  return lines;
+}

package/src/context-profile.ts

@@ -0,0 +1,182 @@
+/**
+ * 上下文画像：**全插件唯一的「上下文里到底有什么」测量入口**。
+ *
+ * ## 为什么需要
+ *
+ * 之前每条路径只知道自己那一块：prune 看工具结果、trim 看 token 总数、
+ * 沉淀看正文。没人知道 reasoning 已经占到 29.5% —— 那是用户用外部探针量出来的。
+ *
+ * 有了画像之后：
+ * - `lrc_status` 直接展示各类别占比，不用再跑外部脚本
+ * - 日志每 N 步打一行构成，增速异常能立刻看出来
+ * - 不变量测试可以断言「各类别占比不超过上限」
+ *
+ * ## 口径
+ *
+ * 只统计**当前 surface 可见节点**（`session.surface.nodes`），
+ * 已被 compaction/prune 遮蔽的节点不计入 —— 它们不在上下文里。
+ */
+import { classifyEvent } from './event-classify.ts';
+import { isSummaryNode, resolveSessionEvents } from './context-trim.ts';
+
+/** 各类别的字符数。 */
+export interface CategoryChars {
+  /** 系统提示 */
+  system: number;
+  /** 宿主注入上下文（技能目录 / 运行时 / 时间 / 审批） */
+  injected: number;
+  /** 真实用户输入 */
+  user: number;
+  /** 助手正文 */
+  assistantText: number;
+  /** 助手推理 */
+  reasoning: number;
+  /** 工具调用参数 */
+  toolArgs: number;
+  /** 工具结果 */
+  toolResult: number;
+}
+
+/** 一次上下文画像。 */
+export interface ContextProfile {
+  /** surface 可见节点数 */
+  nodes: number;
+  /** 可见字符总数 */
+  totalChars: number;
+  /** 可见节点里的摘要（checkpoint）条数：>3 说明摘要层在堆叠 */
+  checkpoints: number;
+  /** 各类别字符数 */
+  byCategory: CategoryChars;
+  /** 各类别占比（0~1） */
+  shares: CategoryChars;
+}
+
+const EMPTY: CategoryChars = {
+  system: 0,
+  injected: 0,
+  user: 0,
+  assistantText: 0,
+  reasoning: 0,
+  toolArgs: 0,
+  toolResult: 0,
+};
+
+/** 统计内容块里的文本字符数。 */
+function textChars(content: unknown): number {
+  if (typeof content === 'string') return content.length;
+  if (!Array.isArray(content)) return 0;
+  let chars = 0;
+  for (const block of content) {
+    const b = block as { type?: string; text?: unknown };
+    if (b?.type === 'text' && typeof b.text === 'string') chars += b.text.length;
+  }
+  return chars;
+}
+
+/** 统计内容块里的推理字符数。 */
+function reasoningChars(content: unknown): number {
+  if (!Array.isArray(content)) return 0;
+  let chars = 0;
+  for (const block of content) {
+    const b = block as { type?: string; text?: unknown };
+    if (b?.type === 'reasoning' && typeof b.text === 'string') chars += b.text.length;
+  }
+  return chars;
+}
+
+/** 统计内容块里的工具参数字符数。 */
+function toolArgsChars(content: unknown): number {
+  if (!Array.isArray(content)) return 0;
+  let chars = 0;
+  for (const block of content) {
+    const b = block as { type?: string; arguments?: unknown };
+    if (b?.type === 'tool-call' && typeof b.arguments === 'string') chars += b.arguments.length;
+  }
+  return chars;
+}
+
+/**
+ * 测量当前 surface 的上下文构成。
+ *
+ * @param session - 宿主会话
+ * @returns 上下文画像（session 不可读时返回全零）
+ */
+export function profileSurface(session: unknown): ContextProfile {
+  const nodes = (session as { surface?: { nodes?: unknown } })?.surface?.nodes;
+  const events = resolveSessionEvents(session);
+  if (!Array.isArray(nodes) || events === undefined) {
+    return { nodes: 0, totalChars: 0, checkpoints: 0, byCategory: { ...EMPTY }, shares: { ...EMPTY } };
+  }
+
+  const byCategory: CategoryChars = { ...EMPTY };
+  let checkpoints = 0;
+  for (const seq of nodes) {
+    const event = events[seq as number] as
+      | {
+          type?: string;
+          data?: {
+            content?: unknown;
+            message?: { content?: unknown };
+          };
+        }
+      | undefined;
+    if (event === undefined) continue;
+    if (isSummaryNode(event)) checkpoints += 1;
+    const category = classifyEvent(event);
+
+    if (category === 'system') {
+      byCategory.system += textChars(event.data?.content ?? event.data?.message?.content);
+    } else if (category === 'injected') {
+      byCategory.injected += textChars(event.data?.content);
+    } else if (category === 'user') {
+      byCategory.user += textChars(event.data?.content);
+    } else if (category === 'assistant') {
+      const content = event.data?.message?.content;
+      byCategory.assistantText += textChars(content);
+      byCategory.reasoning += reasoningChars(content);
+      byCategory.toolArgs += toolArgsChars(content);
+    } else if (category === 'tool-result') {
+      const content = event.data?.message?.content;
+      // 真实形状：content = [{type:'text', text:'...'}]（实测 223/223 事件如此）。
+      // 历史实现去读 content[0].content（嵌套块），形状猜错 → toolResult 恒为 0%，
+      // 于是「工具结果占满上下文」这件事在画像里完全看不见。两种形状都收。
+      byCategory.toolResult += textChars(content);
+      if (Array.isArray(content)) {
+        for (const block of content) {
+          const nested = (block as { content?: unknown })?.content;
+          if (nested !== undefined) byCategory.toolResult += textChars(nested);
+        }
+      }
+    }
+  }
+
+  const totalChars = Object.values(byCategory).reduce((sum, value) => sum + value, 0);
+  const shares: CategoryChars = { ...EMPTY };
+  if (totalChars > 0) {
+    for (const key of Object.keys(byCategory) as Array<keyof CategoryChars>) {
+      shares[key] = byCategory[key] / totalChars;
+    }
+  }
+
+  return { nodes: nodes.length, totalChars, checkpoints, byCategory, shares };
+}
+
+/** 一行可读摘要（日志与 `lrc_status` 用）。 */
+export function formatProfile(profile: ContextProfile): string {
+  const pct = (value: number): string => `${Math.round(value * 100)}%`;
+  const parts = [
+    `toolResult ${pct(profile.shares.toolResult)}`,
+    `reasoning ${pct(profile.shares.reasoning)}`,
+    `toolArgs ${pct(profile.shares.toolArgs)}`,
+    `user ${pct(profile.shares.user)}`,
+    `injected ${pct(profile.shares.injected)}`,
+    `system ${pct(profile.shares.system)}`,
+    `assistantText ${pct(profile.shares.assistantText)}`,
+  ];
+  // checkpoint 条数是摘要自增殖的直接指标：>3 说明 trim 没能吸收旧摘要
+  const warn = profile.checkpoints > 3 ? ' ⚠摘要堆叠' : '';
+  return (
+    `[lrc][profile] 节点=${profile.nodes} 总字符=${profile.totalChars}` +
+    ` checkpoint=${profile.checkpoints}${warn} | ${parts.join(' ')}`
+  );
+}