@jjh32456/dsh-longlive 1.6.7 → 1.6.8

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 — 已跳过');

package/src/heartbeat.js

@@ -1,24 +1,65 @@
 // Auto-heartbeat for the "正在" live registry.
 //
-// Two clocks keep a bound row fresh without the caller passing sessionId:
-//   1. turn lifecycle — `session/event` with `turn/start` / `turn/end` for a
-//      session this writer has already bound;
+// Two clocks keep a row fresh without the caller passing sessionId:
+//   1. turn lifecycle — `session/event` with `turn/start` / `turn/end`. The
+//      event itself carries the session id, so turn boundaries maintain EVERY
+//      non-subagent session's row (R4.5), bound or not; a missing row is
+//      created on the first boundary (128-row cap respected, R4.3);
 //   2. a fallback interval (`heartbeatMs`, default 15 s, `0` disables), which
-//      is what keeps the row fresh through long tool calls and idle stretches.
+//      keeps rows of sessions bound by a longlive tool call fresh through long
+//      tool calls and idle stretches. It never fabricates rows.
 //
-// Identity is bound, never guessed: the id comes from a tool call's explicit
-// `exec.agent` (see identity.js). Turn events and the timer only refresh ids
-// already in that bound set, so a root-scoped plugin observing every session
-// can never heartbeat somebody else's row.
+// Turn boundaries are a state machine, not a heartbeat: `turn/start` writes
+// `state='running'` plus the turn number, `turn/end` writes
+// `idle`/`waiting`/`blocked` plus the turn number (R4.3). It is event driven,
+// so it still runs when the fallback timer is off (`heartbeatMs: 0`); a timer
+// tick, by contrast, only renews `heartbeatAt` and never touches state or
+// `last_action`.
 //
-// Every write is best effort: a missing/corrupt row, an unset memoryRoot or a
-// racing writer must never fail a tool call or crash the host.
+// Every write is best effort: a missing/corrupt row, an unset memoryRoot, a
+// full registry or a racing writer must never fail a tool call or crash the
+// host.
 
-import { liveTouch, liveUpdate } from './live.js';
+import { liveGet, liveList, liveTouch, liveUpdate } from './live.js';
 import { resolveCurrentSessionId } from './identity.js';
 
 export const DEFAULT_HEARTBEAT_MS = 15_000;
 export const MAX_BOUND_SESSIONS = 64;
+/** DESIGN §2.1 live-row cap; mirrored here so turn boundaries cannot blow it up. */
+export const MAX_LIVE_ROWS = 128;
+
+/**
+ * R4.3 pure state machine: state a live row must carry when a turn starts.
+ * @returns {'running'}
+ */
+export function stateForTurnStart() {
+  return 'running';
+}
+
+/**
+ * R4.3 pure state machine: state a live row must carry when a turn ends.
+ * `waiting`/`blocked` are user-facing promises and survive the turn boundary;
+ * anything else falls back to `idle`.
+ * @param {unknown} priorState declared state read before the turn/end write
+ * @returns {'idle'|'waiting'|'blocked'}
+ */
+export function stateForTurnEnd(priorState) {
+  return priorState === 'waiting' || priorState === 'blocked' ? priorState : 'idle';
+}
+
+/**
+ * Pure description of the live-row patch caused by one turn boundary. Kept
+ * separate from I/O so the state machine can be pinned without a registry.
+ * @param {'turn/start'|'turn/end'} type
+ * @param {{turn?:unknown, priorState?:unknown}} [options]
+ * @returns {{state:string, turn:number|null, kind:'turn', detail:string}}
+ */
+export function turnBoundaryPlan(type, options = {}) {
+  const kind = type === 'turn/end' ? 'turn/end' : 'turn/start';
+  const state = kind === 'turn/start' ? stateForTurnStart() : stateForTurnEnd(options.priorState);
+  const turn = Number.isInteger(options.turn) && options.turn >= 0 ? options.turn : null;
+  return { state, turn, kind: 'turn', detail: turn == null ? kind : `${kind} #${turn}` };
+}
 
 function cleanId(value) {
   if (typeof value !== 'string') return null;
@@ -33,12 +74,19 @@ function cleanId(value) {
  * @param {object} [options]
  * @param {object|null} [options.ctx] host context (used for `session/event`)
  * @param {string} [options.memoryRoot] live-registry root; absent disables writes
- * @param {number} [options.heartbeatMs] fallback interval; `0` disables all
- *   automatic writes (binding still happens through the tool resolver)
+ * @param {number} [options.heartbeatMs] fallback interval; `0` disables the
+ *   timer and tool-call touches (binding still happens through the tool
+ *   resolver). Turn-boundary state writes (`turn/start` → running + turn,
+ *   `turn/end` → idle/waiting/blocked + turn) are event driven and keep
+ *   working, because "no timer" is not "no state machine" (R4.3).
  * @param {() => (Date|number)} [options.now] clock injection for tests
  * @param {Function} [options.touch] `liveTouch` injection for tests
  * @param {Function} [options.update] `liveUpdate` injection for tests (first
  *   registration of a session that has no row yet)
+ * @param {Function} [options.get] `liveGet` injection for tests (turn/end reads
+ *   the prior declared state so waiting/blocked survive)
+ * @param {number} [options.maxRows] live-row cap for rows created by turn
+ *   boundaries (default 128, DESIGN §2.1)
  * @param {Function} [options.setInterval] timer injection for tests
  * @param {Function} [options.clearInterval]
  * @param {Function} [options.resolve] `(exec) => {id, source}` injection
@@ -51,6 +99,9 @@ export function createAutoHeartbeat(options = {}) {
     now,
     touch = liveTouch,
     update = liveUpdate,
+    // Read side, used only to preserve waiting/blocked across turn/end.
+    get = liveGet,
+    maxRows = MAX_LIVE_ROWS,
     setInterval: setIntervalFn = globalThis.setInterval,
     clearInterval: clearIntervalFn = globalThis.clearInterval,
     resolve = (exec) => resolveCurrentSessionId({ ctx, exec }),
@@ -61,7 +112,9 @@ export function createAutoHeartbeat(options = {}) {
     ? memoryRoot.trim()
     : null;
   const interval = typeof heartbeatMs === 'number' ? heartbeatMs : Number(heartbeatMs);
-  // Only a finite positive interval enables automatic writes; 0/invalid = off.
+  // Only a finite positive interval enables the fallback timer and the
+  // tool-call touches; 0/invalid = those two off. Turn-boundary state writes
+  // (R4.3) are event driven and deliberately independent of this flag.
   const enabled = Number.isFinite(interval) && interval > 0;
 
   const bound = new Set();
@@ -156,18 +209,82 @@ export function createAutoHeartbeat(options = {}) {
     return touched;
   }
 
+  /**
+   * Prior row snapshot for a turn boundary: does it exist, and what state does
+   * it declare? Read-only; never throws. `known:false` means the read itself
+   * failed, in which case we still attempt the write (liveUpdate is atomic and
+   * the row keeps its prior values for omitted fields).
+   */
+  function readPriorRow(id) {
+    if (root == null || typeof get !== 'function') return { known: false, found: false, state: null };
+    const config = { memoryRoot: root };
+    const at = stamp();
+    if (at !== undefined) config.now = at;
+    try {
+      const got = get({ sessionId: id }, config);
+      if (got?.ok === true) {
+        return { known: true, found: true, state: typeof got.live?.state === 'string' ? got.live.state : null };
+      }
+      if (got?.status === 'absent') return { known: true, found: false, state: null };
+      // corrupt/unreadable-but-present: it occupies a slot; a write repairs it.
+      return { known: true, found: true, state: null };
+    } catch {
+      return { known: false, found: false, state: null };
+    }
+  }
+
+  /** True when a NEW row may still be created without exceeding the 128 cap. */
+  function hasRowCapacity() {
+    if (root == null || typeof liveList !== 'function') return true;
+    const config = { memoryRoot: root };
+    const at = stamp();
+    if (at !== undefined) config.now = at;
+    try {
+      const listed = liveList({ includeDead: true }, config);
+      const scanned = Number.isInteger(listed?.scanned)
+        ? listed.scanned
+        : (Array.isArray(listed?.entries) ? listed.entries.length : 0);
+      return scanned < maxRows;
+    } catch {
+      // Cannot tell -> do not create rows, but an existing row may be updated.
+      return false;
+    }
+  }
+
+  /** One best-effort live-row patch at a turn boundary (state + turn + action). */
+  function writeTurnBoundary(id, { state, turn, kind, detail }) {
+    if (root == null || typeof update !== 'function') return { ok: false, status: 'disabled' };
+    const args = { sessionId: id, state, last_action: { kind, detail } };
+    if (Number.isInteger(turn) && turn >= 0) args.turn = turn;
+    const config = { memoryRoot: root };
+    const at = stamp();
+    if (at !== undefined) config.now = at;
+    try {
+      return update(args, config);
+    } catch {
+      // A state-machine write is decoration for other sessions, never the
+      // turn itself: swallow and let the turn proceed.
+      return { ok: false, status: 'error' };
+    }
+  }
+
   function onSessionEvent(session, event) {
     let id = null;
+    let origin = null;
     try {
-      id = cleanId(session?.id) ?? cleanId(session?.header?.id);
+      id = cleanId(session?.id)
+        ?? cleanId(session?.header?.id)
+        ?? cleanId(event?.session?.id)
+        ?? cleanId(event?.session?.header?.id);
+      const header = session?.header ?? session?.session?.header ?? event?.session?.header ?? {};
+      origin = typeof header.origin === 'string' ? header.origin : null;
     } catch {
       id = null;
     }
     // Auto-truncation watches every session in this agent's scope, not only
     // the ones bound to the live registry: a session that never called a
     // longlive tool can still grow past the threshold. It runs before the
-    // `enabled` gate so `heartbeatMs:0` (live writes off) does not also turn
-    // maintenance off.
+    // live-state gate so `heartbeatMs:0` does not also turn maintenance off.
     if (typeof onTurnEnd === 'function' && event?.type === 'turn/end' && id) {
       try {
         onTurnEnd({ session, event, sessionId: id, turn: event?.data?.turn });
@@ -175,15 +292,31 @@ export function createAutoHeartbeat(options = {}) {
         /* automation is best effort; never fail the host feed */
       }
     }
-    if (!enabled) return;
-    if (!id || !bound.has(id)) return;
     const type = event?.type;
+    if (!id) return;
     if (type !== 'turn/start' && type !== 'turn/end') return;
+    // R4.6: subagents are counted separately on the board; they never get a
+    // live row from the heartbeat (same rule as the Router's L1 writer).
+    if (origin === 'subagent') return;
+    if (root == null || typeof update !== 'function') return;
     const turn = event?.data?.turn;
-    touchOne(id, {
-      kind: 'turn',
-      detail: turn == null ? type : `${type} #${turn}`,
-    });
+    // R4.5: the event carries the session id, so turn boundaries maintain
+    // EVERY non-subagent session's row — a session that only runs native tools
+    // (never calls a longlive tool, so it is never `bind`ed) must still switch
+    // state/turn. Create the row on its first boundary, within the 128 cap.
+    const prior = readPriorRow(id);
+    if (!prior.found && !hasRowCapacity()) return;
+    if (type === 'turn/start') {
+      // R4.3 状态机：turn/start 立刻让 live 行 state: 'running' 并写入 turn 号
+      // （liveUpdate 一次完成；与心跳 tick 无关，tick 只续 heartbeatAt）。
+      const plan = turnBoundaryPlan('turn/start', { turn });
+      writeTurnBoundary(id, plan);
+      return;
+    }
+    // turn/end: idle/blocked/waiting 都落 turn 号；waiting/blocked 是给用户
+    // 看的承诺，turn 结束不能把它抹成 idle。
+    const endPlan = turnBoundaryPlan('turn/end', { turn, priorState: prior.state });
+    writeTurnBoundary(id, endPlan);
   }
 
   function tick() {

package/src/identity/handover.js

@@ -416,6 +416,41 @@ function allocateBudget(parts, total) {
   return budgets;
 }
 
+/**
+ * R6.2: 「状态卡写于 X 分钟前」——X 是 STATE.md mtime 与 now 的差，不是卡片
+ * 生成时间，也不是会话开始时间。拿不到 mtime 时返回 ''（宁可不写，不编造）。
+ * @param {unknown} ageMs
+ * @returns {string}
+ */
+export function stateCardAgeText(ageMs) {
+  if (typeof ageMs !== 'number' || !Number.isFinite(ageMs)) return '';
+  const minutes = Math.max(0, Math.round(ageMs / 60000));
+  return `状态卡写于 ${minutes} 分钟前`;
+}
+
+/**
+ * Resolve the STATE.md age in ms from explicit inputs, falling back to stat()
+ * on `statePath`. Missing/unknown age returns null — the card then omits the
+ * sentence instead of inventing a number.
+ */
+function resolveStateAgeMs(input, safeNow) {
+  if (typeof input.stateAgeMs === 'number' && Number.isFinite(input.stateAgeMs)) {
+    return Math.max(0, input.stateAgeMs);
+  }
+  let mtimeMs = typeof input.stateMtimeMs === 'number' && Number.isFinite(input.stateMtimeMs)
+    ? input.stateMtimeMs
+    : null;
+  if (mtimeMs === null && typeof input.statePath === 'string' && input.statePath.trim() !== '') {
+    try {
+      mtimeMs = fs.statSync(input.statePath).mtimeMs;
+    } catch {
+      mtimeMs = null;
+    }
+  }
+  if (mtimeMs === null) return null;
+  return Math.max(0, safeNow.getTime() - mtimeMs);
+}
+
 /**
  * 生成开机卡。纯函数：所有输入显式传入，方便覆盖缺失/超长/中文路径等边界。
  * @param {{
@@ -424,11 +459,14 @@ function allocateBudget(parts, total) {
  *   maxChars?: number,
  *   now?: Date|number|string,
  *   statePath?: string,
+ *   stateMtimeMs?: number,
+ *   stateAgeMs?: number,
  *   handoverPath?: string,
  * }} [input]
  * @returns {{
  *   text:string, chars:number, truncated:boolean, warnings:string[],
  *   found:Record<string,boolean>, handoverName:string|null,
+ *   stateAgeMinutes:number|null,
  * }}
  */
 export function buildOpenCard(input = {}) {
@@ -439,6 +477,8 @@ export function buildOpenCard(input = {}) {
     ? input.now
     : new Date(input.now ?? Date.now());
   const safeNow = Number.isFinite(now.getTime()) ? now : new Date();
+  const stateAgeMs = resolveStateAgeMs(input, safeNow);
+  const stateAgeMinutes = stateAgeMs === null ? null : Math.max(0, Math.round(stateAgeMs / 60000));
   const warnings = [];
   const stateText = typeof input.stateText === 'string' ? normalizeText(input.stateText) : '';
   if (input.stateText === null || input.stateText === undefined) warnings.push('STATE_MISSING');
@@ -458,7 +498,8 @@ export function buildOpenCard(input = {}) {
   if (!input.handover) warnings.push('HANDOVER_MISSING');
   else if (handoverText.trim() === '') warnings.push('HANDOVER_EMPTY');
 
-  const header = `【开机卡】${formatCardTime(safeNow)}`;
+  const ageText = stateCardAgeText(stateAgeMs);
+  const header = `【开机卡】${formatCardTime(safeNow)}${ageText === '' ? '' : ` · ${ageText}`}`;
   const headings = {
     where: '▍我在哪',
     waiting: '▍在等什么',
@@ -516,6 +557,7 @@ export function buildOpenCard(input = {}) {
     warnings,
     found: { ...parsed.found, handover: handoverText.trim() !== '' },
     handoverName,
+    stateAgeMinutes,
   };
 }
 
@@ -558,6 +600,14 @@ export function collectOpenCard(options = {}) {
   const errors = [];
   const stateRead = readTextFile(statePath);
   if (!stateRead.ok) errors.push(`STATE_READ_FAILED:${stateRead.error}`);
+  // R6.2: the open card must say how old the state card is. Read the mtime
+  // once here; a missing file leaves it unknown and the sentence is omitted.
+  let stateMtimeMs = null;
+  try {
+    stateMtimeMs = fs.statSync(statePath).mtimeMs;
+  } catch {
+    stateMtimeMs = null;
+  }
 
   let handover = null;
   let handoverPath = null;
@@ -593,6 +643,7 @@ export function collectOpenCard(options = {}) {
     maxChars: options.maxChars,
     now: options.now,
     statePath,
+    stateMtimeMs,
     handoverPath: handoverPath ?? undefined,
   });
 

package/src/live.js

@@ -82,6 +82,9 @@ export const LIVE_RECORD_FIELDS = Object.freeze([
   'state',
   'turn',
   'goal',
+  // R3: the clock of the *goal*, not of the row. A heartbeat touch must never
+  // move it (see liveTouch), and the board renders focus.updatedAt from it.
+  'goalUpdatedAt',
   'blocked_on',
   'queued',
   'last_action',
@@ -410,6 +413,9 @@ function decodeRecord(text, expectedSessionId) {
   }
   const updatedMs = parseTime(raw.updatedAt) ?? heartbeatMs;
   const startedMs = parseTime(raw.startedAt) ?? heartbeatMs;
+  // R3 additive field: rows written before this version simply have no goal
+  // clock; keep it as '' (unknown) instead of inventing one from heartbeatAt.
+  const goalUpdatedMs = parseTime(raw.goalUpdatedAt);
   if (!Array.isArray(raw.queued) || !raw.queued.every((item) => typeof item === 'string')) {
     return { ok: false, reason: 'queued 必须是字符串数组' };
   }
@@ -427,6 +433,7 @@ function decodeRecord(text, expectedSessionId) {
       state: raw.state,
       turn: Number.isInteger(raw.turn) && raw.turn >= 0 ? raw.turn : 0,
       goal: typeof raw.goal === 'string' ? raw.goal : '',
+      goalUpdatedAt: goalUpdatedMs != null ? isoTime(goalUpdatedMs) : '',
       blocked_on: typeof raw.blocked_on === 'string' ? raw.blocked_on : '',
       queued: [...raw.queued],
       last_action: normalizeLastAction(raw.last_action, updatedMs),
@@ -485,6 +492,9 @@ function liveEntry(record, { file, root, now, hostname }) {
     pidAlive: alive,
     turn: record.turn,
     goal: record.goal,
+    // R3: the goal write clock (ISO) or null when the row never declared one.
+    // Never derived from heartbeatAt — that is exactly the lie R3 fixes.
+    goalUpdatedAt: record.goalUpdatedAt === '' ? null : record.goalUpdatedAt,
     blocked_on: record.blocked_on,
     queued: record.queued,
     last_action: record.last_action,
@@ -513,6 +523,7 @@ function corruptEntry({ sessionId, file, root, reason, hostHint = null, hostname
     pidAlive: null,
     turn: null,
     goal: '',
+    goalUpdatedAt: null,
     blocked_on: '',
     queued: [],
     last_action: null,
@@ -852,6 +863,12 @@ export function liveUpdate(args = {}, config = {}) {
   const base = prior.record;
   const created = base == null;
   const goal = fit ? fit.value : (base?.goal ?? '');
+  // R3: `goalUpdatedAt` is the goal's own clock. Only a write that supplies a
+  // goal stamps it; patches and heartbeat touches keep the previous value, so
+  // "目标 30 分钟没更新" can be told apart from "心跳 5 秒前刚动过".
+  const goalUpdatedAt = goalInput !== undefined
+    ? isoTime(now)
+    : (base?.goalUpdatedAt ?? '');
   // blocked_on describes a blocked session; anything else clears it, so a
   // running row cannot keep advertising an obstacle nobody is waiting on.
   const priorBlockedOn = base?.blocked_on ?? '';
@@ -873,6 +890,7 @@ export function liveUpdate(args = {}, config = {}) {
     state,
     turn: turn ?? base?.turn ?? 0,
     goal,
+    goalUpdatedAt,
     blocked_on: blockedOn,
     queued: queued.value,
     last_action: lastAction.value,
@@ -940,8 +958,10 @@ export function liveUpdate(args = {}, config = {}) {
  *   - it never creates a row (`status:'absent'` instead), so merely running a
  *     longlive tool does not fabricate a session row;
  *   - it never repairs/lists corrupt rows (`status:'corrupt'`, bytes untouched);
- *   - it preserves `state`, `goal`, `blocked_on`, `queued`, `turn`, `startedAt`
- *     and `ttlMs`: heartbeat says "this writer is still here", not "state changed";
+ *   - it preserves `state`, `goal`, `goalUpdatedAt`, `blocked_on`, `queued`,
+ *     `turn`, `startedAt` and `ttlMs`: heartbeat says "this writer is still
+ *     here", not "state changed". In particular the goal's own clock must not
+ *     move, or the board could no longer tell a stale goal from a live one;
  *   - `lastAction:false` keeps `last_action` exactly as-is (the timer tick);
  *     otherwise only the action stamp is replaced, bounded like every other write.
  */