@jjh32456/dsh-longlive 1.6.6 → 1.6.8

package/src/compaction/engine-core.js

@@ -342,21 +342,31 @@ function roughPointerTokens(text) {
 }
 
 /**
- * Select the oldest whole completed turns that sit outside the retention
- * window. Returns null when no safe cut exists (the common, expected answer).
+ * Select the oldest whole closed turns that sit outside the retention window.
+ * Returns null when no safe cut exists; every such refusal reports a structured
+ * reason through `helpers.onNoPlan` so a silently disabled hot truncate is
+ * observable (the engine logs it once per reason).
  *
- * The host protects surface position 0 when it holds the system prompt: a
- * user/message replacement may not shadow that node. This engine's contract is
- * stronger than the host's: a `system/message` is never part of a cut. The span
- * therefore starts at the first user/assistant node after every leading
- * system node, and a system node anywhere inside a candidate span is a hard
- * right boundary. Checkpoint nodes at the head of the span are folded into the
- * same cut, which keeps exactly one pointer.
+ * The leading run of `system/message` / `developer/message` nodes (the real
+ * system prompt at host-protected position 0) is never moved. A `system/message`
+ * re-injected by a host restart further inside the surface is an archived copy
+ * of that same prompt (host-tolerated inside a replacement range). Checkpoint
+ * nodes at the head of the span are folded into the same cut, which keeps
+ * exactly one pointer.
  */
 export function selectCutPlan(session, options, measurement, helpers = {}) {
   const table = helpers.table ?? turnTable(session);
   const groups = surfaceGroups(session, table, helpers.isCheckpointSource);
-  if (groups.length === 0) return null;
+  const onNoPlan = typeof helpers.onNoPlan === 'function' ? helpers.onNoPlan : null;
+  const noPlan = (reason, detail) => {
+    try {
+      onNoPlan?.({ reason, detail: detail === undefined ? null : detail });
+    } catch {
+      // Diagnostics never break a plan.
+    }
+    return null;
+  };
+  if (groups.length === 0) return noPlan('no-groups');
   const tokens = new Map();
   for (const node of measurement?.nodes ?? []) {
     if (node && typeof node.seq === 'number' && Number.isFinite(node.tokens)) tokens.set(node.seq, node.tokens);
@@ -386,29 +396,37 @@ export function selectCutPlan(session, options, measurement, helpers = {}) {
       break;
     }
   }
-  if (boundary <= 0) return null;
+  if (boundary <= 0) return noPlan('not-enough-turns', { groups: groups.length });
 
   const surfaceNodes = session?.surface?.nodes ?? [];
-  if (surfaceNodes.length === 0) return null;
+  if (surfaceNodes.length === 0) return noPlan('no-surface');
 
-  // 2026-11-06 1.6.6 hotfix — the aborted-turn freeze, second attempt.
+  // 2026-11-06 1.6.7 hardening — no permanent barrier, no silent zero progress.
   //
-  // 1.6.5 stopped an aborted/unfinished turn from returning null, but it kept
-  // the old "never cut an aborted turn" rule: the span was moved *after* the
-  // last aborted turn in the prefix. When aborted turns recur near the tail
-  // (restart-aborted / interrupted turns; real session 2026-11-06: turns 48,
-  // 74, 85, 90, 94), the last one sits right before the retention boundary, so
-  // the plan degenerates to "cut the single completed turn after it" (6–18k
-  // tokens) while every older completed turn (≈370k tokens) stays pinned in
-  // the surface as a permanent prefix. That is the exact shape of the
-  // 396k-token context.
+  // 1.6.6 removed the aborted-turn freeze but treated every group without a
+  // usable turn record as an immovable open group and stopped the span before
+  // it. Three surface shapes then made the planner return null forever even
+  // though whole closed turns older than the retention window existed:
+  //   * a log truncated mid-turn leaves orphan messages at the surface head
+  //     (no turn/start) — a turn===0 group at the head (red team E1);
+  //   * the host appends a user/message between turns — a turn===0 group in
+  //     the middle (red team E3);
+  //   * a turn whose turn/end was lost by log truncation — turn N has no
+  //     endSeq but later turns exist (red team E2).
   //
-  // A turn with a `turn/end` event is closed: it never gains new events, its
-  // tool pairs are complete by construction, and cutting it whole keeps the
-  // pairing balanced. Only a turn with no `turn/end` yet (the currently open
-  // turn, or a turn the log was truncated inside) must stay in place. So the
-  // span may now cover closed-but-not-completed turns; `cutTurnGroups` below
-  // includes them and the archive copies the full turn range via byNumber.
+  // Rules now:
+  //   * the whole LEADING run of system/message + developer/message nodes is
+  //     never moved (head instructions; host-protected position 0);
+  //   * a turn===0 group that carries a system/developer node is a head
+  //     instruction zone and stays in place; a turn===0 group of plain messages
+  //     is an orphan prefix and is archived with the cut (recoverable);
+  //   * a group whose turn has no turn/end is the CURRENT turn only when it is
+  //     the last started turn; an earlier turn without turn/end is abandoned
+  //     (the log was truncated inside it) and is cuttable, archived through an
+  //     inferred range up to the next turn/start;
+  //   * the planner skips a blocked head barrier and cuts the next run of
+  //     wholly-cuttable groups; if nothing is cuttable it reports the reason
+  //     through onNoPlan instead of returning null silently.
   const groupStart = new Array(groups.length);
   const groupEnd = new Array(groups.length);
   const groupOfPosition = new Array(surfaceNodes.length);
@@ -420,99 +438,118 @@ export function selectCutPlan(session, options, measurement, helpers = {}) {
       groupEnd[index] = cursor - 1;
     }
   }
+  const typeOfSeq = (seq) => table.bySeq.get(seq)?.type;
+  const isInstructionSeq = (seq) => typeOfSeq(seq) === 'system/message' || typeOfSeq(seq) === 'developer/message';
+  const protectedSeqs = new Set();
+  {
+    let position = 0;
+    while (position < surfaceNodes.length && isInstructionSeq(surfaceNodes[position])) {
+      protectedSeqs.add(surfaceNodes[position]);
+      position += 1;
+    }
+  }
+  const lastStarted = table.turns.length > 0 ? table.turns[table.turns.length - 1] : null;
   const turnInfoOf = (group) => (group.kind === 'turn' && group.turn !== 0 ? table.byNumber.get(group.turn) : undefined);
-  const isOpenGroup = (group) => {
+  const isCurrentTurnGroup = (group) => {
+    if (group.kind !== 'turn' || group.turn === 0) return false;
+    const info = table.byNumber.get(group.turn);
+    if (info === undefined) return true;
+    return info.endSeq === null && lastStarted !== null && info.turn === lastStarted.turn;
+  };
+  const isCuttableGroup = (group) => {
+    if (group === undefined) return false;
+    if (group.kind === 'checkpoint') return true;
     if (group.kind !== 'turn') return false;
-    if (group.turn === 0) return true;
-    const info = turnInfoOf(group);
-    return info === undefined || info.endSeq === null;
+    // A turn===0 group is either an orphan head zone (contains instructions) or
+    // a stray message block between turns; only the latter may be archived.
+    if (group.turn === 0) return !group.seqs.some((seq) => isInstructionSeq(seq));
+    const info = table.byNumber.get(group.turn);
+    if (info === undefined) return false;
+    return !isCurrentTurnGroup(group);
+  };
+  // An abandoned turn (no turn/end, but a later turn/start exists) never got a
+  // closing event; the archive range is inferred up to the next turn/start so
+  // every one of its original events stays recoverable.
+  const resolvedEndSeq = (group) => {
+    const info = table.byNumber.get(group.turn);
+    const lastSurfaceSeq = group.seqs[group.seqs.length - 1];
+    if (info === undefined || !Number.isInteger(info.startSeq)) return lastSurfaceSeq;
+    if (Number.isInteger(info.endSeq)) return info.endSeq;
+    const next = table.turns.find((entry) => Number.isInteger(entry.startSeq) && entry.startSeq > info.startSeq);
+    if (next === undefined) return lastSurfaceSeq;
+    return Math.max(info.startSeq, next.startSeq - 1);
   };
 
-  // The head of the surface is the real system prompt: the host protects
-  // position 0 and this engine keeps the whole leading run of system/message
-  // nodes in place. The span starts at the first user/assistant node after it.
+  // The span starts after the protected head run and on a user/assistant node
+  // (the pointer replaces one); a system copy skipped at the head of a turn
+  // stays outside the span exactly like 1.6.6 — it is never moved out.
   let startIndex = 0;
-  while (startIndex < surfaceNodes.length
-    && table.bySeq.get(surfaceNodes[startIndex])?.type === 'system/message') {
-    startIndex += 1;
-  }
-  // The pointer replaces a user/assistant message, so the first cut node must
-  // be one. A leading developer node is kept in place instead of cut.
+  while (startIndex < surfaceNodes.length && protectedSeqs.has(surfaceNodes[startIndex])) startIndex += 1;
   while (startIndex < surfaceNodes.length) {
-    const type = table.bySeq.get(surfaceNodes[startIndex])?.type;
+    const type = typeOfSeq(surfaceNodes[startIndex]);
     if (type === 'user/message' || type === 'assistant/message') break;
     startIndex += 1;
   }
-  if (startIndex >= surfaceNodes.length) return null;
-  // A leading group may start with the injected system prompt and continue with
-  // the turn's own nodes. The system nodes stay outside; the span starts at the
-  // first non-system node of that group — the skipped prefix is system-only, so
-  // no user/assistant/tool node is left half-cut. A group whose head contains
-  // non-system nodes is kept whole instead.
-  let startGroup = groupOfPosition[startIndex];
-  while (startGroup < groups.length && groupStart[startGroup] < startIndex) {
-    let systemOnlyHead = true;
-    for (let position = groupStart[startGroup]; position < startIndex; position += 1) {
-      if (table.bySeq.get(surfaceNodes[position])?.type !== 'system/message') { systemOnlyHead = false; break; }
-    }
-    if (systemOnlyHead) break;
-    startIndex = groupEnd[startGroup] + 1;
-    while (startIndex < surfaceNodes.length) {
-      const type = table.bySeq.get(surfaceNodes[startIndex])?.type;
-      if (type === 'user/message' || type === 'assistant/message') break;
-      startIndex += 1;
+  if (startIndex >= surfaceNodes.length) return noPlan('no-span-start');
+  const firstGroup = groupOfPosition[startIndex];
+
+  // Earliest run of consecutive cuttable groups that lies entirely before the
+  // retention boundary and holds at least one real closed turn. Runs made only
+  // of orphan messages/pointers are not worth a surface rewrite: skip them.
+  let chosenStart = -1;
+  let chosenEnd = -1;
+  for (let index = firstGroup; index < boundary; index += 1) {
+    if (!isCuttableGroup(groups[index])) continue;
+    let runEnd = index;
+    while (runEnd + 1 < boundary && isCuttableGroup(groups[runEnd + 1])) runEnd += 1;
+    let realTurns = 0;
+    for (let cursor = index; cursor <= runEnd; cursor += 1) {
+      if (groups[cursor].kind === 'turn' && groups[cursor].turn !== 0) realTurns += 1;
     }
-    if (startIndex >= surfaceNodes.length) return null;
-    startGroup = groupOfPosition[startIndex];
+    if (realTurns > 0) { chosenStart = index; chosenEnd = runEnd; break; }
+    index = runEnd;
   }
-
-  // Cut everything older than the retention boundary, minus groups that must
-  // stay in place: the currently open/unclosed turn and groups without a turn
-  // record are never part of the span. Every other group is cut whole. This is
-  // what lets a closed aborted turn be removed together with its neighbours
-  // instead of acting as a barrier the span has to jump over.
-  let endGroup = boundary - 1;
-  let blockedAt = -1;
-  for (let index = startGroup; index <= endGroup; index += 1) {
-    if (isOpenGroup(groups[index])) { blockedAt = index; break; }
+  if (chosenStart < 0) {
+    return noPlan('blocked-prefix', {
+      firstGroup,
+      boundary,
+      blocked: groups.slice(firstGroup, boundary).map((group) => `${group.kind}:${group.turn}:${group.completed}`),
+    });
   }
-  if (blockedAt >= 0) endGroup = blockedAt - 1;
-  if (endGroup < startGroup) return null;
-  const endIndex = groupEnd[endGroup];
+  let spanStart = Math.max(startIndex, groupStart[chosenStart]);
+  const endIndex = groupEnd[chosenEnd];
+  if (endIndex < spanStart) return noPlan('empty-span', { chosenStart, chosenEnd });
 
   // A system/message node *inside* the span is a host-restart re-injection of
-  // the same prompt (the protected copy is position 0, handled above). The
-  // previous revision excluded the whole containing turn; in the real session
-  // that pinned turns 66/72/75 (≈100k tokens of ordinary dialogue carrying one
-  // injected copy each) outside every future cut, so the context could never
-  // reach the retention window. The host tolerates later system nodes inside a
-  // replacement range, so an injected copy is archived together with the old
-  // prefix it belongs to. Nodes before the span start are never touched.
-  const shadowedSeqs = surfaceNodes.slice(startIndex, endIndex + 1);
+  // the same prompt; the host tolerates it inside a replacement range and it is
+  // archived together with the old prefix (approved 1.6.6 behaviour).
+  const shadowedSeqs = surfaceNodes.slice(spanStart, endIndex + 1);
   const shadowedSet = new Set(shadowedSeqs);
   const touchedGroups = groups.filter((group) => group.seqs.some((seq) => shadowedSet.has(seq)));
-  if (touchedGroups.some((group) => isOpenGroup(group))) return null;
+  if (touchedGroups.some((group) => isCurrentTurnGroup(group))) return noPlan('current-turn-touched');
+  // No half turn: every touched turn group must be fully shadowed. The only
+  // allowed exception is a system/developer copy skipped at the head of the
+  // first group (it stays on the surface, never half-cut).
   for (const group of touchedGroups) {
     if (group.kind !== 'turn') continue;
     const missing = group.seqs.filter((seq) => !shadowedSet.has(seq));
-    if (missing.some((seq) => table.bySeq.get(seq)?.type !== 'system/message')) return null;
+    if (missing.some((seq) => !isInstructionSeq(seq))) return noPlan('split-group', { turn: group.turn });
   }
   const cutTurnGroups = touchedGroups.filter((group) => {
     if (group.kind !== 'turn' || group.turn === 0) return false;
-    const info = turnInfoOf(group);
-    return info !== undefined && info.endSeq !== null;
+    return !isCurrentTurnGroup(group);
   });
-  if (cutTurnGroups.length === 0) return null;
+  if (cutTurnGroups.length === 0) return noPlan('no-turns', { chosenStart, chosenEnd });
 
-  // Archive every original event of the cut turns, plus any checkpoint node
-  // that positionally lived inside the replaced span (a previous pointer).
+  // Archive every original event of the cut turns, plus any checkpoint node and
+  // orphan (turn===0) message that positionally lived inside the replaced span.
   const archivedSeqs = new Set();
   const archiveEvents = [];
   for (const group of cutTurnGroups) {
-    const startSeq = table.byNumber.get(group.turn)?.startSeq;
-    const endSeq = table.byNumber.get(group.turn)?.endSeq;
-    if (!Number.isInteger(startSeq) || !Number.isInteger(endSeq)) continue;
-    for (let seq = startSeq; seq <= endSeq; seq += 1) {
+    const info = table.byNumber.get(group.turn);
+    if (info === undefined || !Number.isInteger(info.startSeq)) continue;
+    const endSeq = resolvedEndSeq(group);
+    for (let seq = info.startSeq; seq <= endSeq; seq += 1) {
       const event = table.bySeq.get(seq);
       if (event === undefined || archivedSeqs.has(seq)) continue;
       archivedSeqs.add(seq);
@@ -536,13 +573,13 @@ export function selectCutPlan(session, options, measurement, helpers = {}) {
       firstSeq: seqs[0],
       lastSeq: seqs[seqs.length - 1],
       startSeq: info?.startSeq ?? seqs[0],
-      endSeq: info?.endSeq ?? seqs[seqs.length - 1],
+      endSeq: resolvedEndSeq(group),
       surfaceEvents: seqs.length,
       tokens: seqs.reduce((total, seq) => total + prices.get(seq), 0),
     };
   });
   const shadowedTokenCount = shadowedSeqs.reduce((total, seq) => total + prices.get(seq), 0);
-  if (shadowedTokenCount <= 0) return null;
+  if (shadowedTokenCount <= 0) return noPlan('zero-token');
 
   const lastTouchedIndex = groups.indexOf(touchedGroups[touchedGroups.length - 1]);
   const retainedGroups = groups.slice(lastTouchedIndex + 1);
@@ -569,7 +606,9 @@ export function selectCutPlan(session, options, measurement, helpers = {}) {
     retainedTurns,
   });
   const pointerTokens = roughPointerTokens(previewText);
-  if (shadowedTokenCount < pointerTokens + options.minCutTokens) return null;
+  if (shadowedTokenCount < pointerTokens + options.minCutTokens) {
+    return noPlan('pointer-too-large', { shadowedTokenCount, pointerTokens });
+  }
 
   return {
     start: shadowedSeqs[0],
@@ -895,6 +934,14 @@ export function createCutEngine(deps) {
       return selectCutPlan(session, this.options, measurement, {
         table,
         isCheckpointSource: isCompactCheckpointSource,
+        // "cut, or say why not": a refusal that would otherwise be silent is
+        // logged once per reason (warnOnce) so a permanently disabled hot
+        // truncate is always observable in the host log.
+        onNoPlan: (info) => {
+          const reason = String(info?.reason ?? 'unknown');
+          const detail = info?.detail === undefined || info?.detail === null ? '' : ` ${JSON.stringify(info.detail)}`;
+          this.warnOnce(`no-plan:${reason}`, `hot-truncate: 未切（${reason}）${detail}`);
+        },
       });
     }
 

package/src/config.js

@@ -54,7 +54,7 @@ const ZH = {
   recoverOnStart: '启动时收尾或回滚未完成的可见截断事务（默认开启）。',
   keepEvents: 'session_truncate 默认保留的事件数（默认 20000）。',
   recentWriteWindowMs: '最近写入保护窗口；窗口内拒绝截断（默认 60000 毫秒）。',
-  heartbeatMs: '活跃会话心跳间隔（默认 15000 毫秒；0 关闭自动写入）。',
+  heartbeatMs: '活跃会话心跳间隔（默认 15000 毫秒）。0 只关定时心跳与工具调用触发的写；turn 开始/结束仍按状态机维护 state/turn。',
   routerEnabled: '开启 Router 路由服务：判定工具调用并按策略记录/拦截（默认关闭）。',
   routerRuntime: '路由运行时模式：off / shadow / on（默认 off；要记录判定须显式设 shadow 或 on）。',
   routerProvider: 'Router 使用的 provider；留空则用 deepseek-official。',
@@ -107,6 +107,15 @@ const ZH = {
     pollMs: '总线轮询间隔（默认 3000 毫秒；0 关闭轮询）。',
     root: '总线根目录；留空则使用记忆根。',
   },
+  sharedBrain: {
+    $description: '共享大脑活动流：把各会话「正在干什么」写进活动板，每轮只注入未读的新增条目。',
+    activity: {
+      $description: '活动流开关与注入预算（与 presenceBus 无关，失败静默）。',
+      enabled: '开启共享大脑活动流（默认关闭）。',
+      injectMaxChars: '每次注入的总字符上限，含固定头尾（默认 300，范围 60–2000）。',
+      maxItems: '每次最多注入的活动条数（默认 5，范围 1–10）。',
+    },
+  },
   autoMaintenance: {
     $description: '每日维护：本地午夜调度 consolidate 报告与 forget 候选清单。',
     enabled: '开启每日维护（默认关闭）。',
@@ -162,7 +171,7 @@ const EN = {
   recoverOnStart: 'Finish or roll back an interrupted visible-truncation transaction at startup (on by default).',
   keepEvents: 'Default events kept by session_truncate (20000).',
   recentWriteWindowMs: 'Recent-write guard window; truncation is refused inside it (60000 ms).',
-  heartbeatMs: 'Live-session heartbeat interval (15000 ms; 0 disables automatic writes).',
+  heartbeatMs: 'Live-session heartbeat interval (15000 ms). 0 disables only the timer heartbeat and tool-touch writes; turn start/end still maintain state/turn.',
   routerEnabled: 'Enable the Router service: evaluate tool calls and record/deny them by policy (off by default).',
   routerRuntime: 'Router runtime mode: off / shadow / on (default off; set shadow or on to record evaluations).',
   routerProvider: 'Provider used by Router; empty means deepseek-official.',
@@ -215,6 +224,15 @@ const EN = {
     pollMs: 'Bus polling interval (default 3000 ms; 0 disables polling).',
     root: 'Bus root directory; empty means the memory root.',
   },
+  sharedBrain: {
+    $description: 'Shared-brain activity stream: one board row per turn, and only unread rows are injected.',
+    activity: {
+      $description: 'Activity-stream switches and injection budget (independent of presenceBus; failures are silent).',
+      enabled: 'Enable the shared-brain activity stream (off by default).',
+      injectMaxChars: 'Total characters per injection, header/footer included (default 300, range 60–2000).',
+      maxItems: 'Maximum activity rows per injection (default 5, range 1–10).',
+    },
+  },
   autoMaintenance: {
     $description: 'Daily maintenance: schedule consolidate reports and forget candidates at local midnight.',
     enabled: 'Enable daily maintenance (off by default).',
@@ -292,6 +310,14 @@ function schemaOf() {
     root: z.string().description(ZH.presenceBus.root),
   }).collapse();
 
+  const sharedBrain = z.object({
+    activity: z.object({
+      enabled: z.boolean().default(false).description(ZH.sharedBrain.activity.enabled),
+      injectMaxChars: z.number().default(300).description(ZH.sharedBrain.activity.injectMaxChars),
+      maxItems: z.number().default(5).description(ZH.sharedBrain.activity.maxItems),
+    }).collapse(),
+  }).collapse();
+
   const autoMaintenance = z.object({
     enabled: z.boolean().default(false).description(ZH.autoMaintenance.enabled),
     consolidate: z.boolean().default(true).description(ZH.autoMaintenance.consolidate),
@@ -377,6 +403,7 @@ function schemaOf() {
     autoRecall,
     identityCard,
     presenceBus,
+    sharedBrain,
     autoMaintenance,
     routerFace,
     autoTruncate,

package/src/features.js

@@ -9,6 +9,8 @@
 //   identityCard.enabled  -> agent/pre-step (open card, prepend:true)
 //   autoRecall.enabled    -> agent/pre-step (recall, prepend:false) + session/event
 //   presenceBus.enabled   -> session/event (drain this session's bus inbox)
+//   sharedBrain.activity.enabled -> session/event (write this turn's activity)
+//                              + agent/pre-step (inject other sessions' new rows)
 //   autoMaintenance.enabled -> one unref'd timer to the next local midnight
 //                              (consolidate report + forget dry-run pending list;
 //                              no turn hook, so a failure cannot affect a turn)
@@ -40,6 +42,7 @@ import {
 import { apply as applyAutoRecall } from './recall/index.js';
 import { createBus, normalizeSessionId, shouldAckOnTurnEnd } from './bus/bus.mjs';
 import { createMaintenanceScheduler } from './memory/maintenance.js';
+import { normalizeActivityConfig, registerActivityStream } from './activity/index.js';
 import {
   claimFallbackInjection,
   markReceiptFallbackInjected,
@@ -52,6 +55,9 @@ export const FEATURE_DEFAULTS = Object.freeze({
   autoRecall: Object.freeze({ enabled: false, topK: 3, budgetTokens: 2000, everyNTurns: 6 }),
   identityCard: Object.freeze({ enabled: false, path: '<memoryRoot>/STATE.md', maxChars: 800 }),
   presenceBus: Object.freeze({ enabled: false, pollMs: 3000 }),
+  sharedBrain: Object.freeze({
+    activity: Object.freeze({ enabled: false, injectMaxChars: 300, maxItems: 5 }),
+  }),
   autoMaintenance: Object.freeze({
     enabled: false,
     consolidate: true,
@@ -81,6 +87,8 @@ export function normalizeFeatureConfig(config = {}) {
   const auto = value.autoRecall && typeof value.autoRecall === 'object' ? value.autoRecall : {};
   const identity = value.identityCard && typeof value.identityCard === 'object' ? value.identityCard : {};
   const bus = value.presenceBus && typeof value.presenceBus === 'object' ? value.presenceBus : {};
+  const sharedBrain = value.sharedBrain && typeof value.sharedBrain === 'object' ? value.sharedBrain : {};
+  const activity = sharedBrain.activity && typeof sharedBrain.activity === 'object' ? sharedBrain.activity : {};
   const maintenance = value.autoMaintenance && typeof value.autoMaintenance === 'object'
     ? value.autoMaintenance
     : {};
@@ -105,6 +113,9 @@ export function normalizeFeatureConfig(config = {}) {
       pollMs: clampInt(bus.pollMs, FEATURE_DEFAULTS.presenceBus.pollMs, 0, 3600000),
       root: text(bus.root),
     },
+    sharedBrain: {
+      activity: normalizeActivityConfig(activity),
+    },
     autoMaintenance: {
       enabled: bool(maintenance.enabled),
       consolidate: maintenance.consolidate !== false,
@@ -566,6 +577,21 @@ export function registerFeatures(ctx, config = {}, options = {}) {
     enabled.push('presenceBus');
   }
 
+  if (cfg.sharedBrain.activity.enabled) {
+    if (!memoryRoot) {
+      warn('[longlive] sharedBrain.activity 已开启但没有可解析的 memoryRoot — 已跳过');
+    } else {
+      const stream = registerActivityStream(ctx, cfg.sharedBrain.activity, {
+        memoryRoot,
+        // Test seam only; the host config never carries these.
+        now: config.now,
+        privacyScan: typeof config.activityPrivacyScan === 'function' ? config.activityPrivacyScan : undefined,
+        logger: warn,
+      });
+      if (stream.enabled) enabled.push('sharedBrain.activity');
+    }
+  }
+
   if (cfg.autoMaintenance.enabled) {
     if (!memoryRoot) {
       warn('[longlive] autoMaintenance 已开启但没有可解析的 memoryRoot — 已跳过');