prts-terrarchive 0.2.0

package/src/wiki.js

@@ -0,0 +1,111 @@
+/** Wiki 文档角色与标签字段的确定性解析。资料仍保留原始标签文本；这里仅提供检索语义层。 */
+
+export const WIKI_SECTION_VALUES = Object.freeze([
+  '简要介绍', '相关角色', '详细介绍', '剧情高光', '战斗表现', '相关活动', 'trivia', '角色点评',
+  '剧情总结', '关键人物', '角色剧情概括',
+  '所有相关的活动剧情总结', '相关剧情总结', '相关剧情高光', '相关trivia', '相关角色总结',
+])
+
+const WIKI_SECTION_SET = new Set(WIKI_SECTION_VALUES)
+const WIKI_CONTAINER_SECTIONS = new Set(['所有相关的活动剧情总结'])
+const OPEN_TAG = /^<([^>/]+)>$/u
+const CLOSE_TAG = /^<\/([^>]+)>$/u
+
+export function wikiDocumentRole(document = {}) {
+  if (document.document_type !== 'knowledge' || document.document_kind !== 'wiki') return ''
+  const explicit = String(document.wiki_role || '').trim()
+  if (['story', 'character', 'character_activity', 'other'].includes(explicit)) return explicit
+  const path = String(document.path || '')
+  if (path.startsWith('stories/')) return 'story'
+  if (path.startsWith('char_v3/prompt_')) return 'character_activity'
+  if (path.startsWith('char_v3/') && document.character_name) return 'character'
+  return 'other'
+}
+
+export function wikiCharacterName(record = {}) {
+  const metadata = String(record.document?.character_name || '').trim()
+  if (metadata) return metadata
+  // 新版 character_activity 记录直接携带 character_name；旧版未拆分资料包
+  // 仍需从 prompt 首行的“名称:角色名”恢复，以保证升级前后都可检索。
+  for (const line of record.lines || []) {
+    const match = /^名称[：:]\s*(.+)$/u.exec(String(line.text || '').trim())
+    if (match?.[1]) return match[1].trim()
+  }
+  return ''
+}
+
+export function wikiActivityName(document = {}) {
+  const metadata = String(document.activity_name || '').trim()
+  if (metadata) return metadata
+  const role = wikiDocumentRole(document)
+  return role === 'story' || role === 'character_activity'
+    ? String(document.display_title || '').trim() : ''
+}
+
+/** 旧版角色活动 Wiki 将多个活动放在同一篇文档，以活动名称标签划分正文。 */
+export function wikiActivityRanges(record = {}) {
+  const ranges = []
+  const lines = record.lines || []
+  let current = null
+  for (let index = 0; index < lines.length; index += 1) {
+    const text = String(lines[index]?.text || '').trim()
+    const marker = /^<活动名称>\s*(.+?)\s*<\/活动名称>$/u.exec(text)
+    if (marker) {
+      if (current) current.end_line = index
+      current = { name: marker[1].trim(), start_line: index + 1, end_line: lines.length }
+      ranges.push(current)
+    } else if (current && text === '</相关内容>') {
+      current.end_line = index + 1
+      current = null
+    } else if (current && text === '</所有相关的活动剧情总结>') {
+      current.end_line = index
+      current = null
+    }
+  }
+  return ranges
+}
+
+/** 返回标签内部的 1-based 闭区间；标签行本身不包含在范围内。 */
+export function wikiSectionRanges(record = {}, requested = []) {
+  const wanted = new Set((requested || []).map((item) => String(item || '').trim()).filter(Boolean))
+  const ranges = []
+  const lines = record.lines || []
+  for (let markerIndex = 0; markerIndex < lines.length; markerIndex += 1) {
+    const opened = OPEN_TAG.exec(String(lines[markerIndex]?.text || '').trim())
+    const name = opened?.[1]
+    if (!name || !WIKI_SECTION_SET.has(name)
+        || (wanted.size && !wanted.has(name))) continue
+
+    // 角色×活动辅助 Wiki 的子字段是半结构化的：它们没有各自的闭合标签，
+    // 而由下一个字段标签或外层 </相关内容> 隐式结束。容器字段仍优先寻找同名闭合。
+    let boundaryIndex = lines.length
+    for (let index = markerIndex + 1; index < lines.length; index += 1) {
+      const text = String(lines[index]?.text || '').trim()
+      const closed = CLOSE_TAG.exec(text)
+      if (closed?.[1] === name) {
+        boundaryIndex = index
+        break
+      }
+      if (WIKI_CONTAINER_SECTIONS.has(name)) continue
+      const nextOpen = OPEN_TAG.exec(text)
+      if ((nextOpen && WIKI_SECTION_SET.has(nextOpen[1])) || closed) {
+        boundaryIndex = index
+        break
+      }
+    }
+    const startLine = markerIndex + 2
+    const endLine = boundaryIndex
+    if (endLine < startLine) continue
+    ranges.push({ name, start_line: startLine, end_line: endLine,
+      marker_start_line: markerIndex + 1, marker_end_line: boundaryIndex + 1 })
+  }
+  return ranges.sort((left, right) => left.start_line - right.start_line
+    || left.end_line - right.end_line)
+}
+
+export function wikiSectionAt(ranges, lineNumber) {
+  const containing = (ranges || []).filter((range) =>
+    range.start_line <= lineNumber && lineNumber <= range.end_line)
+  return containing.sort((left, right) =>
+    (left.end_line - left.start_line) - (right.end_line - right.start_line))[0] || null
+}

package/tsconfig.rhine.json

@@ -0,0 +1,15 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "ESNext",
+    "lib": ["ES2022", "DOM", "DOM.Iterable"],
+    "moduleResolution": "Bundler",
+    "resolveJsonModule": true,
+    "types": ["vite/client"],
+    "strict": true,
+    "skipLibCheck": true,
+    "noEmit": true,
+    "allowImportingTsExtensions": true
+  },
+  "include": ["ui/rhine/**/*.ts"]
+}

package/ui/rhine/archive-navigation-limit.ts

@@ -0,0 +1,31 @@
+export const ARCHIVE_NAVIGATION_INTERVAL_MS = 350;
+export const MAX_RETURNING_ARCHIVE_FILES = 3;
+
+/** One shared budget for manual row/lane/point navigation; rejected input is not queued. */
+export class ArchiveNavigationLimiter {
+  private lastAccepted = -Infinity;
+  private accepted = 0;
+  private rateLimited = 0;
+  private busyLimited = 0;
+
+  tryAccept(now: number, returningFiles = 0): boolean {
+    if (now - this.lastAccepted < ARCHIVE_NAVIGATION_INTERVAL_MS) {
+      this.rateLimited++;
+      return false;
+    }
+    // Wall-clock throttling alone cannot bound copies when rendering/animation
+    // slows down. Wait for existing returns to settle instead of adding more.
+    if (returningFiles >= MAX_RETURNING_ARCHIVE_FILES) {
+      this.busyLimited++;
+      return false;
+    }
+    this.lastAccepted = now;
+    this.accepted++;
+    return true;
+  }
+
+  stats() {
+    return { intervalMs: ARCHIVE_NAVIGATION_INTERVAL_MS, maxReturningFiles: MAX_RETURNING_ARCHIVE_FILES,
+      accepted: this.accepted, rateLimited: this.rateLimited, busyLimited: this.busyLimited, queued: 0 };
+  }
+}

package/ui/rhine/archive-rack.ts

@@ -0,0 +1,83 @@
+import { mergeSourcesInOrder, sourceIdentity } from './catalogue.ts';
+import type { ArchiveSource } from './types';
+
+type Options = {
+  api(endpoint: string, payload: any, signal?: AbortSignal): Promise<any>;
+  changed(sources: ArchiveSource[]): void;
+  failed(message: string): void;
+};
+
+/** Session-owned bookmarks, with a browser copy retained until synchronization succeeds. */
+export function createArchiveRack(options: Options) {
+  let sessionId = '', generation = new AbortController(), queue = Promise.resolve();
+  let sources: ArchiveSource[] = [], pending = new Map<string, ArchiveSource>(), revision = -1;
+  let requestedRevision = -1, disposed = false;
+  const publish = () => options.changed(structuredClone(sources));
+  const current = (g: AbortController) => !disposed && g === generation;
+  function run(operation: (send: (endpoint: string, payload: any) => Promise<any>, g: AbortController) => Promise<void>) {
+    const g = generation, session = sessionId;
+    const send = async (endpoint: string, payload: any) => {
+      if (!current(g)) throw new DOMException('会话已切换', 'AbortError');
+      const result = await options.api(endpoint, { session_id: session, ...payload }, g.signal);
+      if (result?.ok === false || result?.error) throw new Error(result?.error?.message || result?.error || '档案架同步失败');
+      return result;
+    };
+    const task = queue.then(async () => {
+      if (!current(g)) throw new DOMException('会话已切换', 'AbortError');
+      await operation(send, g);
+      if (!current(g)) throw new DOMException('会话已切换', 'AbortError');
+    });
+    queue = task.catch(error => {
+      if (current(g) && error?.name !== 'AbortError') options.failed('档案架尚未同步给 Agent，资料已保留在此浏览器；可再次点击收藏重试。');
+    });
+    return task;
+  }
+  async function load(send: (endpoint: string, payload: any) => Promise<any>, g: AbortController) {
+    const remote: ArchiveSource[] = []; let cursor: number | null = 0, seen = revision;
+    while (cursor !== null && current(g)) {
+      const result = await send('investigation.get', { section: 'rack', saved_only: true, limit: 128, cursor });
+      for (const source of result.sources || []) remote.push({ ...source, id: source.sourceId || source.id, saved: true,
+        ...(source.agentRead ? { readRanges: source.ranges } : {}) });
+      cursor = result.nextCursor ?? null; seen = result.rack_revision;
+    }
+    if (!current(g)) return;
+    sources = mergeSourcesInOrder(sources, [...remote, ...pending.values()]);
+    revision = seen; publish();
+  }
+  return {
+    setSession(id: string, cached: ArchiveSource[]) {
+      generation.abort(); generation = new AbortController(); sessionId = id; queue = Promise.resolve();
+      sources = structuredClone(cached); pending = new Map(cached.map(s => [sourceIdentity(s), s])); revision = -1; requestedRevision = -1;
+      const initial = [...pending.values()];
+      return run(async (send, g) => {
+        if (initial.length) {
+          await send('investigation.rack', { action: 'import', sources: initial });
+          if (!current(g)) return;
+          for (const source of initial) if (pending.get(sourceIdentity(source)) === source) pending.delete(sourceIdentity(source));
+        }
+        await load(send, g);
+      });
+    },
+    refresh(nextRevision: number) {
+      if (!sessionId || disposed || nextRevision <= revision || nextRevision === requestedRevision) return Promise.resolve();
+      requestedRevision = nextRevision;
+      const g = generation;
+      return run(load).catch(error => { if (current(g)) requestedRevision = -1; throw error; });
+    },
+    save(source: ArchiveSource) {
+      const item = { ...structuredClone(source), saved: true }, key = sourceIdentity(item);
+      pending.set(key, item); sources = mergeSourcesInOrder(sources, [item]); publish();
+      return run(async (send, g) => {
+        const result = await send('investigation.rack', { action: 'add', mutation_id: crypto.randomUUID(), sources: [item] });
+        if (!current(g)) return;
+        if (pending.get(key) === item) pending.delete(key);
+        // A receipt can race a bookmark created elsewhere. Read the complete rack
+        // before treating this revision as locally synchronized.
+        if (result.rack_revision !== revision) await load(send, g);
+        else publish();
+      });
+    },
+    isPending(source: ArchiveSource) { return pending.has(sourceIdentity(source)); },
+    dispose() { disposed = true; generation.abort(); },
+  };
+}

package/ui/rhine/board-plane-transform.ts

@@ -0,0 +1,24 @@
+type Point = { x: number; y: number };
+
+/** Map a DOM rectangle exactly onto the projected corners of a planar label. */
+export function boardPlaneTransform(points: readonly Point[], width: number, height: number): string | null {
+  const [p0, p1, p2, p3] = points;
+  if (points.length !== 4 || !p3 || !Number.isFinite(width) || !Number.isFinite(height) || width <= 0 || height <= 0
+    || points.some(p => !Number.isFinite(p.x) || !Number.isFinite(p.y))) return null;
+  let orientation = 0;
+  for (let index = 0; index < 4; index++) {
+    const a = points[index], b = points[(index + 1) % 4], c = points[(index + 2) % 4];
+    const cross = (b.x - a.x) * (c.y - b.y) - (b.y - a.y) * (c.x - b.x);
+    if (!Number.isFinite(cross) || Math.abs(cross) < 1e-6 || orientation && Math.sign(cross) !== orientation) return null;
+    orientation = Math.sign(cross);
+  }
+  const dx1 = p1.x - p2.x, dx2 = p3.x - p2.x, dx3 = p0.x - p1.x + p2.x - p3.x;
+  const dy1 = p1.y - p2.y, dy2 = p3.y - p2.y, dy3 = p0.y - p1.y + p2.y - p3.y;
+  const determinant = dx1 * dy2 - dx2 * dy1;
+  if (Math.abs(determinant) < 1e-6) return null;
+  const g = (dx3 * dy2 - dx2 * dy3) / determinant;
+  const h = (dx1 * dy3 - dx3 * dy1) / determinant;
+  const a = p1.x - p0.x + g * p1.x, b = p3.x - p0.x + h * p3.x;
+  const d = p1.y - p0.y + g * p1.y, e = p3.y - p0.y + h * p3.y;
+  return `matrix3d(${a / width},${d / width},0,${g / width},${b / height},${e / height},0,${h / height},0,0,1,0,${p0.x},${p0.y},0,1)`;
+}

package/ui/rhine/catalogue.ts

@@ -0,0 +1,72 @@
+import type { ArchiveSource } from './types';
+
+export const ARCHIVE_LANES = ['角色档案', '剧情记录', '世界资料', '时间线', '其他资料'] as const;
+export { SHELF_PAGE_SIZE } from './shelf-layout.ts';
+
+export function archiveLane(source: ArchiveSource): number {
+  if (/timeline/.test(source.kind)) return 3;
+  if (/character|operator|voice|module|skin/.test(source.kind)) return 0;
+  if (/story|activity|original/.test(source.kind)) return 1;
+  if (/entity|world|wiki|organization|faction|item|enemy/.test(source.kind)) return 2;
+  return 4;
+}
+
+/** Citation and discovery alone do not establish that the Agent read a source. */
+export function belongsOnShelf(source: ArchiveSource): boolean {
+  return Boolean(source.saved || source.agentRead || source.state === 'read' || source.readRanges?.length);
+}
+
+/** Resolve the same version and any known locator, independent of shelf membership. */
+export function sourceIndex(catalogue: ArchiveSource[], source: ArchiveSource): number {
+  return catalogue.findIndex(item => (item.dataVersion || '') === (source.dataVersion || '') &&
+    (item.id === source.id || (['documentId', 'documentUid', 'sourceRef'] as const).some(key => source[key] && source[key] === item[key])));
+}
+
+export function sourceIdentity(source: ArchiveSource): string {
+  // `id` survives enrichment with a local locator. Merging below resolves
+  // alternate IDs before the scene uses this stable, version-bound identity.
+  return `${source.dataVersion || ''}:${source.id}`;
+}
+
+/** Preserve shelf order and explicit read/citation evidence when results recur. */
+export function mergeSourcesInOrder(previous: ArchiveSource[], incoming: ArchiveSource[]): ArchiveSource[] {
+  const rank = { found: 0, read: 1, cited: 2 };
+  const sources: (ArchiveSource | null)[] = [];
+  const aliases = new Map<string, number>();
+  const keys = (source: ArchiveSource) => [
+    ['id', source.id], ['document', source.documentId],
+    ['uid', source.documentUid], ['ref', source.sourceRef],
+  ].flatMap(([type, value]) => value ? [JSON.stringify([source.dataVersion || '', type, value])] : []);
+  const combine = (old: ArchiveSource, source: ArchiveSource): ArchiveSource => ({ ...old, ...source,
+      id: old.id,
+      kind: ['corpus_read', 'reference', 'source'].includes(source.kind) ? old.kind : source.kind,
+      state: rank[old.state] > rank[source.state] ? old.state : source.state,
+      agentRead: Boolean(old.agentRead || source.agentRead || old.state === 'read' || source.state === 'read'
+        || old.readRanges?.length || source.readRanges?.length),
+      saved: old.saved || source.saved,
+      origin: old.origin === 'cloud' ? 'cloud' : source.origin,
+      excerpt: source.excerpt || old.excerpt,
+      documentId: source.documentId || old.documentId,
+      documentUid: source.documentUid || old.documentUid,
+      sourceRef: source.sourceRef || old.sourceRef,
+      ranges: [...new Map([...(old.ranges || []), ...(source.ranges || [])].map(r => [`${r.start}:${r.end}`, r])).values()],
+      readRanges: [...new Map([...(old.readRanges || []), ...(source.readRanges || [])].map(r => [`${r.start}:${r.end}`, r])).values()],
+    });
+  for (const source of [...previous, ...incoming]) {
+    const matches = [...new Set(keys(source).flatMap(key => aliases.has(key) ? [aliases.get(key)!] : []))].sort((a, b) => a - b);
+    const index = matches[0] ?? sources.length;
+    let merged = sources[index] || null;
+    // A newly delivered locator can join two earlier aliases. Keep the first
+    // shelf position and retain every range before updating it with new data.
+    for (const duplicate of matches.slice(1)) {
+      if (sources[duplicate]) merged = merged ? combine(merged, sources[duplicate]!) : sources[duplicate];
+      sources[duplicate] = null;
+      for (const [key, value] of aliases) if (value === duplicate) aliases.set(key, index);
+    }
+    merged = merged ? combine(merged, source) : { ...source,
+      agentRead: Boolean(source.agentRead || source.state === 'read' || source.readRanges?.length) };
+    sources[index] = merged;
+    for (const key of [...keys(source), ...keys(merged)]) aliases.set(key, index);
+  }
+  return sources.filter((source): source is ArchiveSource => source !== null);
+}

package/ui/rhine/deferred-preparation.ts

@@ -0,0 +1,146 @@
+export interface PreparationScheduler {
+  requestAnimationFrame(callback: FrameRequestCallback): number;
+  cancelAnimationFrame(handle: number): void;
+  setTimeout(callback: () => void, delay: number): number;
+  clearTimeout(handle: number): void;
+}
+
+export interface DeferredPreparationOptions {
+  scheduler?: PreparationScheduler;
+  onError?: (error: unknown, key: string) => void;
+  /** Optional diagnostics. Receives no source keys; failures cannot interrupt the queue. */
+  monitorTask?: () => ((stage: 'sync' | 'settled', succeeded: boolean) => void) | undefined;
+}
+
+type PreparationTask = () => void | Promise<void>;
+type PendingTask = { task: PreparationTask; priority: number };
+
+/** Prepare at most one object after each animation-frame opportunity. */
+export class DeferredPreparation {
+  private readonly scheduler: PreparationScheduler;
+  private readonly onError: (error: unknown, key: string) => void;
+  private readonly monitorTask: DeferredPreparationOptions['monitorTask'];
+  private readonly pending = new Map<string, PendingTask>();
+  private active = true;
+  private disposed = false;
+  private running = false;
+  private completed = 0;
+  private frame: number | undefined;
+  private timer: number | undefined;
+  private generation = 0;
+
+  constructor(options: DeferredPreparationOptions = {}) {
+    this.monitorTask = options.monitorTask;
+    this.scheduler = options.scheduler ?? {
+      requestAnimationFrame: callback => globalThis.requestAnimationFrame(callback),
+      cancelAnimationFrame: handle => globalThis.cancelAnimationFrame(handle),
+      setTimeout: (callback, delay) => globalThis.setTimeout(callback, delay),
+      clearTimeout: handle => globalThis.clearTimeout(handle),
+    };
+    this.onError = options.onError ?? ((error, key) => {
+      console.error(`Archive preparation failed: ${key}`, error);
+    });
+  }
+
+  /** Higher priority runs first. Replacing a pending key preserves FIFO order. */
+  enqueue(key: string, task: PreparationTask, priority = 0) {
+    if (this.disposed) return;
+    this.pending.set(key, { task, priority: Number.isFinite(priority) ? priority : 0 });
+    this.schedule();
+  }
+
+  /** Running work owns its cleanup; cancellation only removes pending work. */
+  cancel(key: string) {
+    this.pending.delete(key);
+    if (this.pending.size === 0) this.cancelScheduled();
+  }
+
+  setActive(active: boolean) {
+    if (this.disposed || this.active === active) return;
+    this.active = active;
+    if (active) this.schedule();
+    else this.cancelScheduled();
+  }
+
+  dispose() {
+    if (this.disposed) return;
+    this.disposed = true;
+    this.pending.clear();
+    this.cancelScheduled();
+  }
+
+  stats() {
+    return { pending: this.pending.size, running: this.running, completed: this.completed };
+  }
+
+  private cancelScheduled() {
+    this.generation++;
+    if (this.frame !== undefined) this.scheduler.cancelAnimationFrame(this.frame);
+    if (this.timer !== undefined) this.scheduler.clearTimeout(this.timer);
+    this.frame = undefined;
+    this.timer = undefined;
+  }
+
+  private schedule() {
+    if (this.disposed || !this.active || this.running || this.pending.size === 0 ||
+      this.frame !== undefined || this.timer !== undefined) return;
+    const generation = this.generation;
+    this.frame = this.scheduler.requestAnimationFrame(() => {
+      if (generation !== this.generation) return;
+      this.frame = undefined;
+      if (this.disposed || !this.active) return;
+      // Work in a subsequent task, not inside the scene's animation callback.
+      this.timer = this.scheduler.setTimeout(() => {
+        if (generation !== this.generation) return;
+        this.timer = undefined;
+        this.runNext();
+      }, 0);
+    });
+  }
+
+  private runNext() {
+    if (this.disposed || !this.active || this.running) return;
+    let selectedKey: string | undefined;
+    let selected: PendingTask | undefined;
+    for (const [key, pending] of this.pending) {
+      if (!selected || pending.priority > selected.priority) {
+        selected = pending;
+        selectedKey = key;
+      }
+    }
+    if (!selected || selectedKey === undefined) return;
+    const key = selectedKey;
+    this.pending.delete(key);
+    this.running = true;
+    let monitor: ReturnType<NonNullable<DeferredPreparationOptions['monitorTask']>>;
+    try { monitor = this.monitorTask?.(); } catch { /* diagnostics must not affect preparation */ }
+    const report = (stage: 'sync' | 'settled', succeeded: boolean) => { try { monitor?.(stage, succeeded); } catch { /* isolated */ } };
+    let result: void | Promise<void>;
+    try {
+      result = selected.task();
+    } catch (error) {
+      report('sync', false); report('settled', false);
+      this.settle(key, false, error);
+      return;
+    }
+    report('sync', true);
+    Promise.resolve(result).then(
+      () => { report('settled', true); this.settle(key, true); },
+      error => { report('settled', false); this.settle(key, false, error); },
+    );
+  }
+
+  private settle(key: string, succeeded: boolean, error?: unknown) {
+    this.running = false;
+    if (succeeded) this.completed++;
+    else {
+      try { this.onError(error, key); }
+      catch (handlerError) {
+        // A reporting callback must not reject the task's settlement promise
+        // or leave the remaining preparation queue stalled.
+        console.error("Archive preparation error handler failed.", handlerError);
+      }
+    }
+    this.schedule();
+  }
+}

package/ui/rhine/evidence-board-controls.css

@@ -0,0 +1,22 @@
+/* The view label is projected as a plane, just like the board's RHINE nameplate. */
+.rhine-workbench .rhine-board-toolbar{position:absolute;z-index:9;display:flex;align-items:center;justify-content:space-between;gap:8px;box-sizing:border-box;width:320px;height:45px;padding:0 12px 0 15px;right:auto;bottom:auto;transform-origin:0 0;transition:none;font-family:MiSans,sans-serif;pointer-events:auto;white-space:nowrap;color:#625b50;background:#e8e2d8;border:1px solid #b5ab9b66;border-left:3px solid #b0a28b;box-shadow:0 1.5px 0 #786e5c33;backface-visibility:hidden}
+.rhine-workbench .rhine-board-view-caption{font-size:8px;letter-spacing:1.4px;color:#958978;user-select:none}
+.rhine-workbench .rhine-board-magnet{display:flex;height:100%;align-items:center;gap:0}
+.rhine-workbench .rhine-board-magnet:last-child{border-left:1px solid #b5ab9b66;padding-left:9px}
+.rhine-workbench .rhine-board-toolbar button{display:inline-flex;align-items:center;justify-content:center;gap:8px;box-sizing:border-box;height:100%;min-width:32px;padding:0 6px;border:0;border-radius:0;background:transparent;color:inherit;font:inherit;font-size:13px;cursor:pointer}
+.rhine-workbench .rhine-board-toolbar button:hover{color:#5d4632;background:#b9a79620}
+.rhine-workbench .rhine-board-toolbar button:disabled{opacity:.3;cursor:default}
+.rhine-workbench .rhine-board-toolbar button:focus-visible,.rhine-workbench .rhine-board-chalk-hit:focus-visible{outline:2px solid #a38558;outline-offset:2px}
+.rhine-workbench .rhine-board-toolbar .rhine-board-reset{min-width:49px;font-variant-numeric:tabular-nums;font-size:12px;color:#736856}
+.rhine-workbench .rhine-board-toolbar .rhine-board-zoom-out,.rhine-workbench .rhine-board-toolbar .rhine-board-zoom-in{font-size:17px;font-weight:300}
+.rhine-workbench .rhine-board-fullscreen-toggle svg{width:13px;height:13px;fill:none;stroke:currentColor;stroke-width:1.2}
+.rhine-workbench .rhine-board-toolbar.is-docked{width:240px;height:40px;padding-inline:8px;gap:2px;background:#ede8de}
+.rhine-workbench .rhine-board-toolbar.is-docked .rhine-board-view-caption{display:none}
+.rhine-workbench .rhine-board-toolbar.is-docked button{font-size:11px;padding-inline:5px;gap:5px}
+/* Invisible keyboard/touch target over the real object; no floating badge or box. */
+.rhine-workbench .rhine-board-chalk-hit{position:absolute;z-index:8;width:48px;height:48px;transform:scale(var(--board-ui-scale,1));transform-origin:0 0;padding:0;border:0;background:transparent;cursor:pointer;touch-action:manipulation}
+.rhine-workbench .rhine-board-tool-status{position:absolute;z-index:14;left:50%;bottom:calc(90px * var(--board-ui-scale,1));display:flex;align-items:center;gap:14px;max-width:calc(90% / var(--board-ui-scale,1));padding:9px 13px;background:#f4eee2;border:1px solid #c6b49b;color:#7b674c;transform:translateX(-50%) scale(var(--board-ui-scale,1));transform-origin:50% 100%;font:11px/1.6 MiSans,sans-serif;box-shadow:0 4px 14px #77624712}
+.rhine-workbench .rhine-board-tool-cancel{flex-shrink:0;border:0;background:none;color:#986d4c;font:inherit;cursor:pointer;padding:4px}
+.rhine-workbench.rhine-board-fullscreen .rhine-board-tool-status{bottom:calc(30px * var(--board-ui-scale,1))}
+.rhine-workbench [data-layout=portrait] .rhine-board-tool-status{max-width:calc(92% / var(--board-ui-scale,1));bottom:115px;gap:8px;font-size:10px}
+.rhine-workbench.rhine-board-fullscreen [data-layout=portrait] .rhine-board-tool-status{bottom:24px}

package/ui/rhine/evidence-board-history.ts

@@ -0,0 +1,73 @@
+import type { EvidenceCard } from './evidence-board-model';
+
+export type EvidenceSnapshot = {
+  cards: EvidenceCard[];
+  selected: string | null;
+  promotions: [string, string][];
+};
+type Entry = { before: EvidenceSnapshot; after: EvidenceSnapshot; label: string; group?: string; time: number };
+const copy = (state: EvidenceSnapshot): EvidenceSnapshot => ({
+  cards: state.cards.map(card => ({ ...card, ...(card.position ? { position: { ...card.position } } : {}),
+    ...(card.links ? { links: [...card.links] } : {}) })),
+  selected: state.selected, promotions: state.promotions.map(([from, to]) => [from, to]),
+});
+const sameCards = (a: EvidenceSnapshot, b: EvidenceSnapshot) => JSON.stringify(a.cards) === JSON.stringify(b.cards);
+
+/** Session-local history. Selection-only changes never occupy an undo step. */
+export function createEvidenceHistory(limit = 40) {
+  const past: Entry[] = [], future: Entry[] = [];
+  let mergeOpen = false;
+  return {
+    record(before: EvidenceSnapshot, after: EvidenceSnapshot, label: string, group?: string, time = Date.now()) {
+      if (sameCards(before, after)) return false;
+      const last = past.at(-1);
+      if (mergeOpen && group && last?.group === group && time - last.time < 1500 && sameCards(last.after, before)) {
+        last.after = copy(after); last.time = time;
+        if (sameCards(last.before, last.after)) past.pop();
+      } else {
+        past.push({ before: copy(before), after: copy(after), label, group, time });
+        if (past.length > limit) past.shift();
+      }
+      future.length = 0; mergeOpen = Boolean(group); return true;
+    },
+    undo() {
+      mergeOpen = false;
+      const entry = past.pop(); if (!entry) return null;
+      future.push(entry); return { state: copy(entry.before), from: copy(entry.after), label: entry.label };
+    },
+    redo() {
+      mergeOpen = false;
+      const entry = future.pop(); if (!entry) return null;
+      past.push(entry); return { state: copy(entry.after), from: copy(entry.before), label: entry.label };
+    },
+    remapIds(mapping: Record<string, string>, revisions: Record<string, { content_revision: number; layout_revision: number }> = {}) {
+      for (const entry of [...past, ...future]) for (const state of [entry.before, entry.after]) {
+        state.cards = state.cards.map(card => {
+          const id = mapping[card.id] || card.id, revision = id !== card.id ? revisions[id] : undefined;
+          return { ...card, id, ...(revision ? { contentRevision: revision.content_revision, layoutRevision: revision.layout_revision } : {}), links: card.links?.map(id => mapping[id] || id) };
+        });
+        if (state.selected) state.selected = mapping[state.selected] || state.selected;
+      }
+    },
+    seal() { mergeOpen = false; },
+    clear() { past.length = 0; future.length = 0; mergeOpen = false; },
+    stats() { return { undoCount: past.length, redoCount: future.length, undoLabel: past.at(-1)?.label,
+      redoLabel: future.at(-1)?.label }; },
+  };
+}
+
+/** Apply only this user's inverse fields; retain later agent additions and edits. */
+export function rebaseEvidenceHistory(current: EvidenceCard[], from: EvidenceCard[], to: EvidenceCard[]) {
+  const result = structuredClone(current);
+  const keys = ['title','body','summary','kind','stage','position','rotation','scale','links'] as const;
+  const equal = (a: unknown, b: unknown) => JSON.stringify(a) === JSON.stringify(b);
+  for (const old of from) {
+    const desired = to.find(card => card.id === old.id), index = result.findIndex(card => card.id === old.id);
+    if (index < 0) continue;
+    if (!desired) { if (keys.every(key => equal(result[index][key], old[key]))) result.splice(index, 1); continue; }
+    const next = result[index] as Record<string, unknown>;
+    for (const key of keys) if (!equal(old[key], desired[key]) && equal(next[key], old[key])) next[key] = structuredClone(desired[key]);
+  }
+  for (const desired of to) if (!from.some(card => card.id === desired.id) && !result.some(card => card.id === desired.id)) result.push(structuredClone(desired));
+  return result;
+}