@jjh32456/dsh-longlive 1.6.8 → 1.8.0

package/src/activity/index.js

@@ -31,12 +31,14 @@ import {
   textOfMessage,
 } from '../identity/inject-position.js';
 import { privacyScan as defaultPrivacyScan } from '../recall/privacy.mjs';
+import { startPrestepPhase, notePrestepDegrade } from '../metrics/prestep-latency.mjs';
 import {
   ACTIVITY_HINT_MARK,
   ACTIVITY_REFRESH_THROTTLE_MS,
   buildActivityKey,
   buildActivityText,
   buildToolActivityText,
+  charLength,
   classifyKind,
   clip,
   oneLine,
@@ -44,6 +46,14 @@ import {
   selectActivities,
   shortSessionId,
 } from './model.js';
+import {
+  THINKING_HINT_MARK,
+  extractThinkingText,
+  isThinkingPayloadSafe,
+  renderThinkingHint,
+  selectThinkingActivities,
+  summarizeThinking,
+} from './thinking.js';
 import {
   ACTIVITY_SESSION_RE,
   activityBoardFile,
@@ -56,7 +66,9 @@ export const ACTIVITY_STATE_VERSION = 1;
 export const ACTIVITY_STATE_DIR = path.join('.longlive', 'bridge');
 
 export const ACTIVITY_DEFAULTS = Object.freeze({
-  enabled: false,
+  // 1.8.0 product default: real-time shared memory is ON by default; users opt
+  // out with an explicit `enabled: false` (never by omission).
+  enabled: true,
   injectMaxChars: 300,
   maxItems: 5,
 });
@@ -71,7 +83,8 @@ function clampInt(value, fallback, min, max) {
 export function normalizeActivityConfig(input = {}) {
   const raw = input !== null && typeof input === 'object' ? input : {};
   return {
-    enabled: raw.enabled === true,
+    // Default ON (1.8.0): only a literal false opts out.
+    enabled: raw.enabled !== false,
     injectMaxChars: clampInt(raw.injectMaxChars, ACTIVITY_DEFAULTS.injectMaxChars, 60, 2000),
     maxItems: clampInt(raw.maxItems, ACTIVITY_DEFAULTS.maxItems, 1, 10),
     createUserMessage: typeof raw.createUserMessage === 'function' ? raw.createUserMessage : undefined,
@@ -212,6 +225,9 @@ async function resolveCreateUserMessage(explicit) {
  */
 export function createActivityStream(options = {}) {
   const cfg = normalizeActivityConfig(options);
+  // 1.8.0: thinking summaries are an independent, default-off injection switch.
+  // The write side also requires it, so off is byte-for-byte the 1.7.4 behaviour.
+  const thinkingInjection = options.thinkingInjection === true;
   const memoryRoot = typeof options.memoryRoot === 'string' && options.memoryRoot.trim() !== ''
     ? path.resolve(options.memoryRoot)
     : null;
@@ -231,6 +247,8 @@ export function createActivityStream(options = {}) {
     privacy: 0,
     resets: 0,
     errors: 0,
+    thinkingWritten: 0,
+    thinkingInjected: 0,
   };
   const sessions = new Map();
   // `${sessionId}|${key}` → { at: ms, kind } — 同 key 节流 ≤1 次刷新/10s.
@@ -249,6 +267,8 @@ export function createActivityStream(options = {}) {
         assistantText: '',
         tool: null,
         toolCalls: 0,
+        thinkingTurn: null,
+        thinkingWritten: false,
       };
       sessions.set(sessionId, state);
     }
@@ -386,6 +406,8 @@ export function createActivityStream(options = {}) {
         state.assistantText = '';
         state.tool = null;
         state.toolCalls = 0;
+        state.thinkingTurn = null;
+        state.thinkingWritten = false;
         // A new turn is new information: do not let the previous turn's 10s
         // window swallow its first tool action.
         clearSessionRefreshes(sessionId);
@@ -405,6 +427,40 @@ export function createActivityStream(options = {}) {
         if (Number.isInteger(turn) && Number.isInteger(state.turn) && turn !== state.turn) return;
         const text = messageTextOf(event);
         if (text !== '') state.assistantText = text;
+        // 1.8.0 thinking summaries: at most one row per session+turn; only when
+        // the injection switch is on. Visible reasoning text exists or nothing
+        // is written (no model call, no raw log rewrite).
+        if (thinkingInjection) {
+          const resolvedTurn = Number.isInteger(turn) ? turn : (Number.isInteger(state.turn) ? state.turn : null);
+          const alreadyWritten = state.thinkingWritten
+            && (state.thinkingTurn === resolvedTurn || resolvedTurn === null);
+          if (!alreadyWritten) {
+            const summary = summarizeThinking(extractThinkingText(data.message?.content));
+            if (summary !== '') {
+              const result = store.append(
+                {
+                  sessionId,
+                  kind: 'thinking',
+                  text: summary,
+                  key: `thinking|${resolvedTurn ?? 'turn'}`,
+                  at: now(),
+                  turnRef: resolvedTurn,
+                  charCount: charLength(summary),
+                },
+                { touchSeq: true, refreshText: false },
+              );
+              if (result.ok) {
+                state.thinkingTurn = resolvedTurn;
+                state.thinkingWritten = true;
+                stats.thinkingWritten += 1;
+              } else if (result.code === 'E_PRIVACY') {
+                stats.privacy += 1;
+              } else {
+                stats.errors += 1;
+              }
+            }
+          }
+        }
         return;
       }
 
@@ -473,7 +529,10 @@ export function createActivityStream(options = {}) {
     const messages = payload?.messages;
     if (!Array.isArray(messages)) return skip('no-messages');
     if (!messages.some((message) => isHumanMessage(message))) return skip('empty-turn');
-    if (messages.some((message) => textOfMessage(message).includes(ACTIVITY_HINT_MARK))) {
+    if (messages.some((message) => {
+      const text = textOfMessage(message);
+      return text.includes(ACTIVITY_HINT_MARK) || text.includes(THINKING_HINT_MARK);
+    })) {
       return { injected: false, skipped: 'turn-already-injected' };
     }
 
@@ -494,7 +553,18 @@ export function createActivityStream(options = {}) {
       lastSeenSeq: effectiveSeen,
       maxItems: cfg.maxItems,
     });
-    if (fresh.length === 0) return { injected: false, skipped: 'no-new', reset: resetCursor };
+    // 1.8.0: thinking summaries are selected separately and never mixed into
+    // the normal activity lines (the cursor is the same lastSeenSeq).
+    const freshThinking = thinkingInjection
+      ? selectThinkingActivities(read.entries, {
+        selfSessionId: sessionId,
+        lastSeenSeq: effectiveSeen,
+        maxItems: 5,
+      })
+      : [];
+    if (fresh.length === 0 && freshThinking.length === 0) {
+      return { injected: false, skipped: 'no-new', reset: resetCursor };
+    }
 
     const allowed = [];
     for (const item of fresh) {
@@ -510,14 +580,44 @@ export function createActivityStream(options = {}) {
       }
       allowed.push(item);
     }
-    if (allowed.length === 0) return { injected: false, skipped: 'privacy' };
+    const allowedThinking = [];
+    for (const item of freshThinking) {
+      const summary = summarizeThinking(item.text);
+      if (summary === '' || !isThinkingPayloadSafe(summary)) {
+        stats.privacy += 1;
+        continue;
+      }
+      try {
+        const verdict = privacyScan(summary);
+        if (!verdict || verdict.verdict === 'local_only') {
+          stats.privacy += 1;
+          continue;
+        }
+      } catch {
+        stats.privacy += 1;
+        continue;
+      }
+      allowedThinking.push({ ...item, text: summary });
+    }
+    if (allowed.length === 0 && allowedThinking.length === 0) {
+      return { injected: false, skipped: 'privacy' };
+    }
 
-    const rendered = renderActivityHint(allowed, {
-      maxChars: cfg.injectMaxChars,
-      maxItems: cfg.maxItems,
-      nowMs: now().getTime(),
-    });
-    if (rendered.text === '') return skip('budget-empty');
+    const parts = [];
+    if (allowed.length > 0) {
+      const rendered = renderActivityHint(allowed, {
+        maxChars: cfg.injectMaxChars,
+        maxItems: cfg.maxItems,
+        nowMs: now().getTime(),
+      });
+      if (rendered.text !== '') parts.push(rendered.text);
+    }
+    if (allowedThinking.length > 0) {
+      const thinkingText = renderThinkingHint(allowedThinking, { maxItems: 5 });
+      if (thinkingText !== '') parts.push(thinkingText);
+    }
+    if (parts.length === 0) return skip('budget-empty');
+    const text = parts.join('\n\n');
 
     const createUserMessage = await resolveCreateUserMessage(cfg.createUserMessage);
     if (typeof createUserMessage !== 'function') return skip('no-create-user-message');
@@ -525,7 +625,7 @@ export function createActivityStream(options = {}) {
     try {
       message = assertInjectionSource(createUserMessage({
         role: 'user',
-        content: [{ type: 'text', text: rendered.text }],
+        content: [{ type: 'text', text }],
         source: injectionSource(),
       }));
     } catch {
@@ -539,10 +639,11 @@ export function createActivityStream(options = {}) {
       return skip('splice-failed');
     }
 
+    const injectedItems = [...allowed, ...allowedThinking];
     const nextState = {
       ...state,
       lastSeenSeq: Math.max(effectiveSeen, maxSeqOf(read.entries)),
-      lastInjectedSeq: maxSeqOf(allowed),
+      lastInjectedSeq: maxSeqOf(injectedItems),
       lastInjectedAt: now().toISOString(),
       injectedTurns: state.injectedTurns + 1,
       resets: state.resets + (resetCursor ? 1 : 0),
@@ -555,13 +656,15 @@ export function createActivityStream(options = {}) {
       /* state is an optimization; a failed write costs a repeat, not a turn */
     }
     stats.injected += 1;
+    stats.thinkingInjected += allowedThinking.length;
     return {
       injected: true,
       sessionId,
-      chars: rendered.chars,
+      chars: charLength(text),
       reset: resetCursor,
-      items: allowed.map((item) => ({ seq: item.seq, sessionId: item.sessionId, kind: item.kind })),
-      text: rendered.text,
+      items: injectedItems.map((item) => ({ seq: item.seq, sessionId: item.sessionId, kind: item.kind })),
+      thinkingItems: allowedThinking.length,
+      text,
     };
   }
 
@@ -576,10 +679,16 @@ export function createActivityStream(options = {}) {
     }
     try {
       const dispose = ctx.on('agent/pre-step', async (payload, next) => {
+        // B3: shared phase = shared-brain injection only (timing only).
+        const sessionId = preStepSessionId(payload);
+        const phase = startPrestepPhase(sessionId, payload?.turn, 'shared');
         try {
           await maybeInject(payload);
         } catch {
           stats.errors += 1;
+          notePrestepDegrade(sessionId, payload?.turn, { kind: 'error', phase: 'shared', detail: 'E_ACTIVITY_PRE_STEP' });
+        } finally {
+          phase.end();
         }
         return typeof next === 'function' ? next() : undefined;
       });
@@ -607,7 +716,7 @@ export function createActivityStream(options = {}) {
   return {
     enabled,
     memoryRoot,
-    config: cfg,
+    config: { ...cfg, thinkingInjection },
     stats,
     store,
     install,
@@ -625,10 +734,11 @@ export function createActivityStream(options = {}) {
  */
 export function registerActivityStream(ctx, cfg = {}, options = {}) {
   const stream = createActivityStream({
-    enabled: cfg.enabled === true,
+    enabled: cfg.enabled !== false,
     memoryRoot: options.memoryRoot,
     injectMaxChars: cfg.injectMaxChars,
     maxItems: cfg.maxItems,
+    thinkingInjection: cfg.thinkingInjection === true,
     createUserMessage: cfg.createUserMessage,
     now: options.now,
     privacyScan: options.privacyScan,
@@ -647,3 +757,4 @@ export function registerActivityStream(ctx, cfg = {}, options = {}) {
 }
 
 export { ACTIVITY_HINT_MARK, ACTIVITY_REFRESH_THROTTLE_MS, shortSessionId, activityBoardFile };
+export { THINKING_HINT_MARK, THINKING_KIND, THINKING_LINE_MAX, THINKING_MAX_ITEMS } from './thinking.js';

package/src/activity/model.js

@@ -9,10 +9,12 @@
 import { classifyConclusionText } from '../conclusion.js';
 
 /** One activity row's kind. `doing` is the default, `blocked` floats in hints. */
-export const ACTIVITY_KINDS = Object.freeze(['doing', 'finding', 'blocked', 'done']);
+export const ACTIVITY_KINDS = Object.freeze(['doing', 'finding', 'blocked', 'done', 'thinking']);
 
 /** The published cap for one row's text (code points, not bytes). */
 export const ACTIVITY_TEXT_MAX = 140;
+/** Thinking summaries use their own published cap (one line, ≤200). */
+export const ACTIVITY_THINKING_TEXT_MAX = 200;
 /**
  * Event-level rows (one per tool call) refresh in place instead of appending a
  * new row every time. 同 key 节流 ≤1 条/10s: a refresh inside the window is a
@@ -277,11 +279,14 @@ function clampInt(value, fallback, min, max) {
 /**
  * Pick the incremental rows a session has not seen yet. Ordering: blocked
  * first, then newest first. Rows from the consumer itself never come back.
+ * `thinking` rows are a separate section (thinking.js); they never leak into
+ * this normal activity hint unless the caller explicitly asks for that kind.
  */
 export function selectActivities(entries, options = {}) {
   const selfSessionId = typeof options.selfSessionId === 'string' ? options.selfSessionId : null;
   const lastSeenSeq = Number.isInteger(options.lastSeenSeq) ? options.lastSeenSeq : 0;
   const maxItems = clampInt(options.maxItems, 5, 1, 10);
+  const kinds = Array.isArray(options.kinds) ? new Set(options.kinds) : null;
   const rows = [];
   for (const entry of Array.isArray(entries) ? entries : []) {
     if (!entry || typeof entry !== 'object') continue;
@@ -289,6 +294,11 @@ export function selectActivities(entries, options = {}) {
     if (selfSessionId !== null && entry.sessionId === selfSessionId) continue;
     if (entry.archived === true) continue;
     if (!ACTIVITY_KINDS.includes(entry.kind)) continue;
+    if (kinds !== null) {
+      if (!kinds.has(entry.kind)) continue;
+    } else if (entry.kind === 'thinking') {
+      continue;
+    }
     if (typeof entry.text !== 'string' || entry.text.trim() === '') continue;
     rows.push(entry);
   }

package/src/activity/store.js

@@ -22,10 +22,12 @@ import { privacyScan as defaultPrivacyScan } from '../recall/privacy.mjs';
 import {
   ACTIVITY_KINDS,
   ACTIVITY_TEXT_MAX,
+  ACTIVITY_THINKING_TEXT_MAX,
   DEDUPE_WINDOW,
   DISTILL_MIN_COUNT,
   DISTILL_TOTAL_COUNT,
   SIMILARITY_THRESHOLD,
+  charLength,
   clip,
   distillActivityText,
   normalizeKey,
@@ -338,12 +340,17 @@ export function selectDedupeTarget(entries, candidate, options = {}) {
   const sessionId = String(candidate?.sessionId ?? '');
   const key = normalizeKey(candidate?.key);
   const text = oneLine(candidate?.text);
+  const candidateKind = ACTIVITY_KINDS.includes(candidate?.kind) ? candidate.kind : 'doing';
+  const thinking = candidateKind === 'thinking';
   const rows = (Array.isArray(entries) ? entries : []).filter(
     (entry) => entry && entry.sessionId === sessionId && entry.archived !== true,
   );
   const windowRows = rows.slice(-Math.max(1, windowSize));
   let best = null;
   for (const row of windowRows) {
+    // 1.8.0: thinking summaries and normal activity rows never merge into each
+    // other (different kind = different panel section and different cursors).
+    if ((row.kind === 'thinking') !== thinking) continue;
     if (normalizeKey(row.key) === key) return { row, reason: 'key', score: 1 };
     const score = similarity(row.text, text);
     if (score >= threshold && (best === null || score > best.score)) best = { row, reason: 'similarity', score };
@@ -475,9 +482,10 @@ export function createActivityStore(options = {}) {
     const refreshText = options.refreshText === true;
     const sessionId = String(input.sessionId ?? '').trim().toLowerCase();
     if (!ACTIVITY_SESSION_RE.test(sessionId)) return { ok: false, code: 'E_SESSION_ID' };
-    const text = clip(oneLine(input.text), ACTIVITY_TEXT_MAX);
-    if (text === '') return { ok: false, code: 'E_EMPTY_TEXT' };
     const kind = ACTIVITY_KINDS.includes(input.kind) ? input.kind : 'doing';
+    const textMax = kind === 'thinking' ? ACTIVITY_THINKING_TEXT_MAX : ACTIVITY_TEXT_MAX;
+    const text = clip(oneLine(input.text), textMax);
+    if (text === '') return { ok: false, code: 'E_EMPTY_TEXT' };
     const key = normalizeKey(input.key);
     const atDate = new Date(input.at ?? now());
     const at = Number.isFinite(atDate.getTime()) ? atDate.toISOString() : new Date().toISOString();
@@ -515,7 +523,7 @@ export function createActivityStore(options = {}) {
           };
         }
       }
-      const target = selectDedupeTarget(entries, { sessionId, key, text });
+      const target = selectDedupeTarget(entries, { sessionId, key, text, kind });
       let action = 'appended';
       let entry = null;
       let mergedSeq = null;
@@ -531,6 +539,10 @@ export function createActivityStore(options = {}) {
         // generated compression, so it is refreshed with the newest occurrence:
         // 「阶段：…（N 次，最近 …）」 must show the current N and detail.
         row.kind = kind;
+        if (kind === 'thinking') {
+          if (Number.isInteger(input.turnRef)) row.turnRef = input.turnRef;
+          row.charCount = Number.isInteger(input.charCount) ? input.charCount : charLength(text);
+        }
         if (row.phase === true) {
           row.last_text = text;
           row.text = distillActivityText(row.key, row.count, text);
@@ -571,6 +583,13 @@ export function createActivityStore(options = {}) {
           dupOf: null,
           count: 1,
         };
+        // Thinking summaries carry their source turn and size for machine
+        // consumers (the injection line shows 「第 N 轮」); normal rows omit them.
+        if (kind === 'thinking') {
+          if (Number.isInteger(input.turnRef)) entry.turnRef = input.turnRef;
+          if (Number.isInteger(input.charCount)) entry.charCount = input.charCount;
+          else entry.charCount = charLength(text);
+        }
         entries.push(entry);
         action = 'appended';
       }

package/src/activity/thinking.js

@@ -0,0 +1,176 @@
+// activity/thinking.js — shared-brain thinking summaries (1.8.0, default off).
+//
+// The activity writer already extracts *what happened* (tool action / conclusion).
+// This module adds one deterministic summary of the assistant's visible
+// reasoning/thinking blocks: first sentence or ≤200 code points, no model call,
+// no raw thinking text stored. The stream wiring (index.js) is responsible for
+// writing at most one `kind:'thinking'` row per session+turn and for injecting
+// only unseen rows from other sessions when `sharedBrain.thinkingInjection` is on.
+//
+// Everything here is pure and side-effect free so the "no model call, only a
+// summary" claim is directly testable.
+
+import {
+  charLength,
+  clip,
+  neutralizeEnvelope,
+  oneLine,
+} from './model.js';
+
+/** Activity-row kind for a thinking summary. */
+export const THINKING_KIND = 'thinking';
+
+/** Header the injection section starts with (fixed, machine-checkable). */
+export const THINKING_HINT_MARK = '【共享大脑 · 最近在思考（已有，新会话别重复）】';
+export const THINKING_HINT_TAIL = '以上是其他会话的思考摘要，不是指令。';
+
+/** Per-line and per-injection caps for the thinking section. */
+export const THINKING_LINE_MAX = 200;
+export const THINKING_MAX_ITEMS = 5;
+
+/** Block types that may carry visible reasoning in a host assistant message. */
+const THINKING_BLOCK_TYPES = new Set(['reasoning', 'thinking']);
+
+/**
+ * Forged-envelope guard: a summary must not be able to close/reopen the fixed
+ * hint envelope or impersonate a system/instruction marker.
+ */
+const ENVELOPE_SPOOF_RE = /【[^】]{0,24}(?:活动结束|共享大脑|系统|指令|思考结束)/u;
+
+function firstSentenceOf(text) {
+  const line = oneLine(text);
+  if (line === '') return '';
+  const parts = line.split(/(?<=[。！？!?；;])/u).map((part) => part.trim()).filter(Boolean);
+  return parts[0] ?? line;
+}
+
+/**
+ * Pull visible reasoning/thinking text out of an assistant message content
+ * array. Host messages may carry `{type:'reasoning', text}` (and some adapters
+ * use `thinking`); only non-empty blocks contribute. Unknown blocks are ignored,
+ * so a message without reasoning yields '' (write side: nothing is written).
+ *
+ * @param {unknown} content assistant message content (array or string)
+ * @returns {string}
+ */
+export function extractThinkingText(content) {
+  if (typeof content === 'string') return content.trim();
+  if (!Array.isArray(content)) return '';
+  const parts = [];
+  for (const block of content) {
+    if (!block || typeof block !== 'object') continue;
+    const type = typeof block.type === 'string' ? block.type.toLowerCase() : '';
+    if (!THINKING_BLOCK_TYPES.has(type)) continue;
+    const text = typeof block.text === 'string' ? block.text.trim() : '';
+    if (text !== '') parts.push(text);
+  }
+  return parts.join('\n\n');
+}
+
+/**
+ * Deterministic compression: one physical line, first sentence, ≤200 code
+ * points. Never returns the raw candidate when it is longer than the cap.
+ *
+ * @param {unknown} value
+ * @returns {string}
+ */
+export function summarizeThinking(value) {
+  const raw = oneLine(value);
+  if (raw === '') return '';
+  const summary = firstSentenceOf(raw);
+  return neutralizeEnvelope(clip(summary, THINKING_LINE_MAX));
+}
+
+/**
+ * Payload-safety pre-check for a summary before it is injected. A row that
+ * fails is skipped, never rendered: no empty text, no >200 code points, no
+ * control characters, no forged fixed-envelope markers.
+ *
+ * @param {unknown} value
+ * @returns {boolean}
+ */
+export function isThinkingPayloadSafe(value) {
+  const raw = String(value ?? '');
+  if (raw.trim() === '') return false;
+  if (charLength(raw) > THINKING_LINE_MAX) return false;
+  if (/[\u0000-\u001f\u007f]/u.test(raw)) return false;
+  if (ENVELOPE_SPOOF_RE.test(raw)) return false;
+  if (/【|】/u.test(raw)) return false;
+  return true;
+}
+
+function clampItems(value, fallback = THINKING_MAX_ITEMS) {
+  const number = Number(value);
+  if (!Number.isFinite(number)) return fallback;
+  return Math.min(THINKING_MAX_ITEMS, Math.max(1, Math.floor(number)));
+}
+
+/**
+ * Pick thinking rows this session has not consumed yet. Same cursor semantics
+ * as the activity stream: seq > lastSeenSeq, other sessions only, archived rows
+ * excluded, payload-safe summaries only. Newest rows win when over the cap, but
+ * they are returned oldest→newest so the injected lines read chronologically.
+ *
+ * @param {Array<object>} entries board rows
+ * @param {{selfSessionId?:string,lastSeenSeq?:number,maxItems?:number,lineMax?:number}} [options]
+ * @returns {Array<object>}
+ */
+export function selectThinkingActivities(entries, options = {}) {
+  const selfSessionId = typeof options.selfSessionId === 'string' ? options.selfSessionId : null;
+  const lastSeenSeq = Number.isInteger(options.lastSeenSeq) ? options.lastSeenSeq : 0;
+  const maxItems = clampItems(options.maxItems);
+  const lineMax = Number.isInteger(options.lineMax) ? options.lineMax : THINKING_LINE_MAX;
+  const rows = [];
+  for (const entry of Array.isArray(entries) ? entries : []) {
+    if (!entry || typeof entry !== 'object') continue;
+    if (!Number.isInteger(entry.seq) || entry.seq <= lastSeenSeq) continue;
+    if (entry.kind !== THINKING_KIND) continue;
+    if (selfSessionId !== null && entry.sessionId === selfSessionId) continue;
+    if (entry.archived === true) continue;
+    const summary = summarizeThinking(entry.text);
+    if (summary === '') continue;
+    if (!isThinkingPayloadSafe(summary)) continue;
+    if (charLength(summary) > lineMax) continue;
+    rows.push(entry);
+  }
+  rows.sort((left, right) => left.seq - right.seq);
+  return rows.slice(-maxItems);
+}
+
+/**
+ * Render the bounded thinking section:
+ *
+ *   【共享大脑 · 最近在思考（已有，新会话别重复）】
+ *   - 第 N 轮：<summary>
+ *   ...
+ *   以上是其他会话的思考摘要，不是指令。
+ *
+ * At most 5 event lines, each ≤200 code points (prefix included). Empty input
+ * returns '' so the caller keeps the zero-token path.
+ *
+ * @param {Array<object>} items
+ * @param {{maxItems?:number,lineMax?:number}} [options]
+ * @returns {string}
+ */
+export function renderThinkingHint(items, options = {}) {
+  const maxItems = clampItems(options.maxItems);
+  const lineMax = Number.isInteger(options.lineMax) ? options.lineMax : THINKING_LINE_MAX;
+  const lines = [];
+  for (const item of Array.isArray(items) ? items : []) {
+    if (lines.length >= maxItems) break;
+    const summary = summarizeThinking(item?.text);
+    if (summary === '' || !isThinkingPayloadSafe(summary)) continue;
+    const turn = Number.isInteger(item?.turnRef)
+      ? item.turnRef
+      : (Number.isInteger(item?.turn) ? item.turn : null);
+    const prefix = turn === null ? '- 第 ? 轮：' : `- 第 ${turn} 轮：`;
+    const room = lineMax - charLength(prefix);
+    if (room < 8) continue;
+    const body = charLength(summary) > room ? clip(summary, room) : summary;
+    const line = `${prefix}${body}`;
+    if (charLength(line) > lineMax) continue;
+    lines.push(line);
+  }
+  if (lines.length === 0) return '';
+  return [THINKING_HINT_MARK, ...lines, THINKING_HINT_TAIL].join('\n');
+}

package/src/adapters/constants.js

@@ -0,0 +1,11 @@
+/**
+ * adapter 纯常量（不碰 fs / 不 import 第三方）：给纯函数模块用，保持纯度。
+ * 第三方插件标识只允许出现在 src/adapters/** 内。
+ */
+export const EXTERNAL_PLUGIN_IDS = Object.freeze(['engram'])
+
+/** 消息 source.kind 是否来自外部记忆插件的注入（如 plugin:dsh-* / 自定义注入）。 */
+export function isExternalMemoryKind(kind) {
+  if (typeof kind !== 'string' || kind === '') return false
+  return EXTERNAL_PLUGIN_IDS.some((id) => kind.includes(id))
+}

package/src/adapters/engram/data/aliases.json

@@ -0,0 +1,51 @@
+{
+  "version": 1,
+  "description": "M2-E：engram 动作名归一（含旧工具名兼容）",
+  "actions": [
+    {
+      "canonical": "engram.search",
+      "legacy": "engram_search",
+      "aliases": [
+        "engram_search",
+        "engram.search",
+        "memory_recall"
+      ]
+    },
+    {
+      "canonical": "engram.save",
+      "legacy": "engram_save",
+      "aliases": [
+        "engram_save",
+        "engram.save",
+        "save_memory"
+      ]
+    },
+    {
+      "canonical": "engram.facts.replace",
+      "legacy": "engram_facts",
+      "aliases": [
+        "engram_facts",
+        "engram.facts",
+        "engram.facts.replace"
+      ]
+    },
+    {
+      "canonical": "engram.forget",
+      "legacy": "engram_forget",
+      "aliases": [
+        "engram.forget",
+        "engram_forget",
+        "forget"
+      ]
+    },
+    {
+      "canonical": "engram.profile.edit",
+      "legacy": "engram_profile_edit",
+      "aliases": [
+        "engram.profile.edit",
+        "engram_profile_edit",
+        "profile_edit"
+      ]
+    }
+  ]
+}

package/src/adapters/engram/data/policy.json

@@ -0,0 +1,8 @@
+{
+  "forbiddenActions": [
+    "engram.save"
+  ],
+  "allowPrefixes": [
+    "engram:"
+  ]
+}