termdock 1.4.310 → 1.4.312

package/dist/server/agent/collaborationDeliveryWorker.js

@@ -1,18 +1,9 @@
-import { collaborationMessageAnchorTokens } from './collaborationPrompt.js';
 export class CollaborationDeliveryWorker {
     options;
     running = new Map();
     states = new Map();
     failures = new Map();
     submitted = new Set();
-    /** Sessions whose latest delivery was confirmed rendered in this process,
-     *  mapped to the timestamp until which confirmations are skipped. A recent
-     *  confirmed delivery means the agent is actively consuming input, so
-     *  follow-up messages settle immediately; once the cooldown lapses the
-     *  agent's state is unknown again (it may be mid-turn, or finishing one)
-     *  and the gate re-engages. Settled-but-unconfirmed deliveries never grant
-     *  cooldown — that would re-open the turn-handover hole the gate closes. */
-    confirmedUntil = new Map();
     timer = null;
     ticking = null;
     constructor(options) {
@@ -131,34 +122,6 @@ export class CollaborationDeliveryWorker {
             return;
         }
         const attempts = store.diagnostic(message.id)?.attempt_count ?? 0;
-        // Confirm gate: the route becoming ready only proves the agent process is
-        // up, not that its TUI is consuming — a write landing while the agent
-        // finishes another turn can sit unsubmitted in its input box. When the
-        // route can read terminal history, watch for our message to appear there
-        // (the agent rendered it) and, while it is missing, try the recovery
-        // ladder: submit a paste left unsubmitted in the input box, dismiss a
-        // blocking approval dialog.
-        //
-        // The gate never re-writes the body. A successful write already put the
-        // bytes in the pty; a busy agent that has not echoed them yet is a
-        // diagnosis, not a lost message, and re-writing would deliver the body
-        // again the moment it does catch up (that is how one user message arrived
-        // as three copies). Only a write that throws is treated as a failed
-        // delivery and retried — that path is unchanged.
-        const confirmMs = this.options.firstDeliveryConfirmMs ?? 1_500;
-        const gateActive = !route.isShell && Boolean(route.confirm) && confirmMs > 0
-            && Date.now() >= (this.confirmedUntil.get(id) ?? 0);
-        // Differential baseline for stuck-paste recovery: captured before the
-        // write so a later screen diff can tell our paste apart from stale ones.
-        let baseline = '';
-        if (gateActive && route.recoverStuck && !this.submitted.has(message.id) && route.capture) {
-            try {
-                baseline = (await route.capture()) ?? '';
-            }
-            catch {
-                baseline = '';
-            }
-        }
         if (!this.submitted.has(message.id)) {
             store.recordTransport(message.id, {
                 relay_online: null, peer_reachable: true,
@@ -190,75 +153,18 @@ export class CollaborationDeliveryWorker {
                 catch { /* best-effort */ }
             }
         }
-        if (gateActive) {
-            const confirmed = await this.confirmConsumed(pending, route, confirmMs, baseline, collaborationMessageAnchorTokens(pending));
-            // Confirmed rendered: refresh the exemption window so follow-ups in the
-            // agent's active turn settle immediately.
-            if (confirmed)
-                this.confirmedUntil.set(id, Date.now() + (this.options.confirmCooldownMs ?? 30_000));
-            // Either way the delivery settles here: the bytes are in the pty, and an
-            // unconfirmed one keeps that diagnosis for the sender instead of
-            // re-queuing a body that already arrived.
-            this.complete(id, message, confirmed ? null : 'AGENT_CONSUME_UNCONFIRMED');
-            return;
-        }
         // If persistence fails after writing, the in-process guard avoids a
         // second write on retry. Across a crash, transport is at-least-once.
         this.complete(id, message);
     }
-    /** Wait out the confirm window, then look for the written messages in the
-     *  recipient's terminal history. A message found there was rendered by the
-     *  agent and counts as consumed. While the agent is blocked on an approval
-     *  dialog (its Bash call needs permission) dismiss it once per cycle, and
-     *  on the first cycle submit a paste that arrived during turn handover and
-     *  is still sitting unsubmitted (differential baseline evidence only, at
-     *  most once per delivery). Each recovery sends Enter on evidence, never
-     *  blind. */
-    async confirmConsumed(messages, route, delayMs, baseline, tokens) {
-        let recovered = false;
-        for (let attempt = 0; attempt < 3; attempt += 1) {
-            await new Promise((resolve) => setTimeout(resolve, attempt === 0 ? delayMs : Math.min(1_200, delayMs)));
-            let content = null;
-            try {
-                content = await route.confirm();
-            }
-            catch {
-                content = null;
-            }
-            // Search the same token the formatter wrote into the delivered text:
-            // short ids in the terminal, full ids in `messages`. Deriving it here
-            // rather than reusing a literal is what keeps the two sides from
-            // drifting apart — a text that carries a token the gate does not search
-            // can never confirm, and the delivery is re-written to the bound.
-            if (content && messages.some((message) => content.includes(tokens.get(message.id) ?? message.id)))
-                return true;
-            if (!recovered && route.recoverStuck && baseline) {
-                try {
-                    recovered = await route.recoverStuck(baseline);
-                }
-                catch { /* a failed submit must not settle delivery */ }
-            }
-            if (content && route.approve) {
-                try {
-                    await route.approve();
-                }
-                catch { /* a failed dismiss must not settle delivery */ }
-            }
-        }
-        return false;
-    }
-    /** Settle a delivery as delivered. `unconfirmedReason`, when set, is a
-     *  diagnosis that survives the settle: the write reached the pty (there is
-     *  nothing more a retry may do) but the recipient never showed it, so the
-     *  sender can still see why. Never re-queues — that is what would wedge the
-     *  queue and duplicate the body. */
-    complete(id, message, unconfirmedReason = null) {
+    /** Delivery records terminal writes only; Agent replies are separate. */
+    complete(id, message) {
         const { store } = this.options;
         store.markDelivered([message.id]);
         this.submitted.delete(message.id);
         store.recordTransport(message.id, {
             relay_online: null, peer_reachable: true, attempt_count: store.diagnostic(message.id)?.attempt_count ?? 1,
-            next_retry_at: null, last_error: unconfirmedReason, checked_at: Date.now(),
+            next_retry_at: null, last_error: null, checked_at: Date.now(),
         });
         this.failures.delete(id);
     }

package/dist/server/agent/collaborationTmuxDelivery.js

@@ -1,5 +1,5 @@
 import { plainCollaborationSnapshot } from './collaborationText.js';
-import { normalizePromptForPaste } from './promptDelivery.js';
+import { normalizePromptForPaste, waitForPromptSubmit } from './promptDelivery.js';
 const TMUX_KEY_NAMES = {
     enter: 'Enter', escape: 'Escape', space: 'Space', left: 'Left', right: 'Right', up: 'Up', down: 'Down',
 };
@@ -19,26 +19,9 @@ const APPROVAL_DIALOG_PATTERNS = [
     /\b1\.\s*是\b/,
     /允许.*执行|确认.*执行/i,
 ];
-/** Agent TUIs collapse pasted input in the input box to a marker line like
- * "[Pasted text #3 +42 lines]". While the paste sits unsubmitted the marker
- * stays on screen; a submitted paste clears the box and only the transcript
- * holds the content. Session-unique #N lets us diff screen captures. */
-const PASTE_MARKER_PATTERN = /\[Pasted text #(\d+)/g;
 export function detectApprovalDialog(content) {
     return APPROVAL_DIALOG_PATTERNS.some((pattern) => pattern.test(content));
 }
-/** Paste marker sequence numbers visible in a screen capture. */
-export function extractPasteMarkerNumbers(content) {
-    return new Set([...content.matchAll(PASTE_MARKER_PATTERN)].map((match) => Number(match[1])));
-}
-/** True when `after` shows a paste marker that was not in `before`. Diffing
- * prevents a recovery Enter from submitting a stale paste that predates this
- * delivery (or someone else's draft): we only ever submit what we just put
- * there, at most once per delivery. */
-export function hasNewPasteMarker(after, before) {
-    const beforeNumbers = extractPasteMarkerNumbers(before);
-    return [...extractPasteMarkerNumbers(after)].some((number) => !beforeNumbers.has(number));
-}
 async function assertSamePane(run, pane) {
     const identity = (await run(['display-message', '-p', '-t', pane.paneId,
         '#{pid}:#{session_id}:#{pane_id}:#{pane_pid}'])).trim();
@@ -48,15 +31,19 @@ async function assertSamePane(run, pane) {
 /** Unique-per-process buffer name so concurrent deliveries to different panes
  *  never share (or clobber) a buffer. */
 let bufferSequence = 0;
-export async function writeCollaborationTmuxPane(run, pane, prompt, 
-/** Sends `input` to the tmux client's stdin. The steps below are one `\;`
- *  chain (see the comment inside), and a chain is argv, so the body must not
- *  ride in argv: tmux treats an element that is exactly `;` as a separator
- *  even after `--`, and its backslash unescaping is version-dependent
- *  (`\\` survives verbatim while `\;` collapses to `;`). Reading the body
- *  from stdin sidesteps both — every byte round-trips unchanged. Required,
- *  not optional: a run() that ignored the payload would load an empty buffer
- *  and fail the delivery rather than deliver the wrong thing. */
+const paneWrites = new Map();
+/** Serialize TD paste/submit pairs for this exact runtime pane. */
+export function writeCollaborationTmuxPane(run, pane, prompt, stdin) {
+    const key = `${pane.serverPid}:${pane.sessionId}:${pane.paneId}:${pane.panePid}`;
+    const previous = paneWrites.get(key) ?? Promise.resolve();
+    const operation = previous.catch(() => undefined).then(() => writeTmuxPrompt(run, pane, prompt, stdin))
+        .finally(() => { if (paneWrites.get(key) === operation)
+        paneWrites.delete(key); });
+    paneWrites.set(key, operation);
+    return operation;
+}
+async function writeTmuxPrompt(run, pane, prompt, 
+/** Body travels on stdin so tmux cannot parse its semicolons/backslashes. */
 stdin) {
     await assertSamePane(run, pane);
     // A fixed pane target is independent of the current window, keyboard focus
@@ -77,13 +64,8 @@ stdin) {
     // every tmux version.
     const buffer = `termdock-collab-${process.pid}-${bufferSequence++}`;
     try {
-        // The four steps ride one client invocation joined by tmux's `\;`: the
-        // server runs them back to back in a single queue item, so no other
-        // client's paste can interleave between our text and our submit CR
-        // (measured: one contiguous block, 0ms apart, versus two invocations
-        // ~14ms apart). A failing step stops the rest — verified on 3.4 and 3.7 —
-        // which is the safe direction: a failed text paste is never followed by a
-        // bare CR into whatever the input box already held.
+        // Paste once, then send one unbracketed CR after 50ms. No screen parsing,
+        // Agent-specific recovery, consumption confirmation or additional Enter.
         await stdin([
             // The body arrives on stdin, not argv: it is user content, and in a
             // `\;` chain argv is a language where `;` and `\` mean something.
@@ -91,13 +73,17 @@ stdin) {
             // -r keeps LF as LF rather than the separator default of CR. The
             // normalizer already folded every line break to CR, so no LF is left
             // for it to rewrite — the flag is insurance, not the mechanism.
-            'paste-buffer', '-p', '-r', '-d', '-b', buffer, '-t', pane.paneId, ';',
+            'paste-buffer', '-p', '-r', '-d', '-b', buffer, '-t', pane.paneId,
+        ], normalizePromptForPaste(prompt));
+        await waitForPromptSubmit();
+        await assertSamePane(run, pane);
+        await run([
             // The submit key rides outside the paste block: inside it, an editor
             // inserts a pasted CR as text instead of acting on it. Pasting the bare
             // CR (no -p) keeps the key in the same mode-proof channel as the text.
             'set-buffer', '-b', buffer, '--', '\r', ';',
             'paste-buffer', '-d', '-b', buffer, '-t', pane.paneId,
-        ], normalizePromptForPaste(prompt));
+        ]);
     }
     finally {
         // -d consumed the buffer on the happy path; this sweeps up after a failed
@@ -139,21 +125,7 @@ export async function approveCollaborationDialog(run, pane) {
     await sendTmuxPaneKey(run, pane, 'enter');
     return true;
 }
-/** Submit a paste that arrived while the agent was finishing its previous
- *  turn and is still sitting unsubmitted in the input box. Only acts on
- *  differential evidence — a paste marker that appeared after the write —
- *  never on pre-existing stale markers, and returns whether Enter was sent.
- *  Committing the whole input buffer is safe: each delivery is written once,
- *  so each marker's content enters the transcript exactly once. */
-export async function recoverStuckPaste(run, pane, baseline) {
-    const viewport = await captureTmuxPaneText(run, pane);
-    if (!hasNewPasteMarker(viewport, baseline))
-        return false;
-    await sendTmuxPaneKey(run, pane, 'enter');
-    return true;
-}
-/** History-inclusive pane text (scrollback + viewport) used to confirm a
- *  delivery was actually rendered by the agent, not wiped by a boot clear. */
+/** History-inclusive terminal observation, without inferring consumption. */
 export async function captureTmuxPaneHistory(run, pane, lines = 800, rawOutput = false) {
     await assertSamePane(run, pane);
     if (!Number.isInteger(lines) || lines < 1 || lines > 10000)

package/dist/server/agent/integrationServer.js

@@ -224,6 +224,7 @@ export class IntegrationRuntime {
             startup_input_conditions: true, session_runtime_release: true, stable_session_identity: true, session_lifecycle_generation: true,
             session_resume_configuration: true, session_lifecycle_min_version: '1.4.309',
             session_startup_input_clear: true, session_startup_input_clear_min_version: '1.4.310',
+            agent_launch_process_check: true, agent_launch_process_check_min_version: '1.4.312',
             integration_policy_update: true,
             session_restore_diagnostics: true,
             native_identity_linux_flock_owner: process.platform === 'linux',

package/dist/server/agent/promptDelivery.js

@@ -8,13 +8,26 @@
 export function normalizePromptForPaste(prompt) {
     return prompt.replace(/\r\n|\r|\n/g, '\r').replace(/\x1b/g, '␛');
 }
-/**
- * Encode a prompt as one bracketed-paste block followed by one real Enter.
- * Agent TUIs then keep embedded newlines inside the editor instead of treating
- * each line as a separate submission.
- */
-export function buildBracketedSubmitBytes(prompt) {
-    return `\x1b[200~${normalizePromptForPaste(prompt)}\x1b[201~\r`;
+/** Separate the paste and its single unbracketed CR by 50ms. */
+export const PROMPT_SUBMIT_DELAY_MS = 50;
+export function waitForPromptSubmit() {
+    return new Promise((resolve) => setTimeout(resolve, PROMPT_SUBMIT_DELAY_MS));
+}
+export function buildBracketedPasteBytes(prompt) {
+    return `\x1b[200~${normalizePromptForPaste(prompt)}\x1b[201~`;
+}
+const promptWrites = new WeakMap();
+/** Serialize TD prompt pairs per PTY. Success only records terminal writes. */
+export function writeBracketedPrompt(target, prompt) {
+    const previous = promptWrites.get(target) ?? Promise.resolve();
+    const operation = previous.catch(() => undefined).then(async () => {
+        target.write(buildBracketedPasteBytes(prompt));
+        await waitForPromptSubmit();
+        target.write('\r');
+    }).finally(() => { if (promptWrites.get(target) === operation)
+        promptWrites.delete(target); });
+    promptWrites.set(target, operation);
+    return operation;
 }
 /**
  * Process detection and hook events are independent Agent signals. A target is

package/dist/server/architecture/cli.js

@@ -29,6 +29,19 @@ Fields: description, diagram, context, constraint, concern, todo, note.
 Examples: td architecture prompt --project .
           td architecture write --format omm overall-architecture/auth description -
           td architecture save --file .termdock/architecture.json -`;
+function elementPath(view, node) {
+    if (!node)
+        return view.id;
+    if (node.documentPath)
+        return node.documentPath;
+    const parts = [node.id];
+    let parent = node.parentId;
+    while (parent) {
+        parts.unshift(parent);
+        parent = view.nodes.find(item => item.id === parent)?.parentId;
+    }
+    return [view.id, ...parts].join('/');
+}
 function target(document, element) {
     const [perspective, ...parts] = element.split('/');
     const view = document.perspectives.find(view => view.id === perspective);
@@ -78,10 +91,14 @@ export async function runArchitectureCli(args, io = { write: value => process.st
         if (options.format && !['native', 'omm'].includes(options.format))
             throw new Error('Format must be native or omm');
         const file = options.file ?? (omm ? '.omm' : ARCHITECTURE_FILE);
+        const instructions = async () => {
+            const language = options.language ?? (omm ? (await store.config()).language : 'en');
+            return omm ? buildOmmScanPrompt(root, language) : buildArchitecturePrompt(root, language === 'zh' ? 'zh' : 'en');
+        };
         const input = async (values) => values[0] === '-' ? io.stdin() : values.join(' ');
         const json = (value) => io.write(JSON.stringify(value, null, 2));
         if (command === 'prompt' || command === 'scan') {
-            io.write(omm ? buildOmmScanPrompt(root, options.language === 'zh' ? 'zh' : 'en') : buildArchitecturePrompt(root, options.language === 'zh' ? 'zh' : 'en'));
+            io.write(await instructions());
             return 0;
         }
         if (command === 'setup') {
@@ -112,7 +129,7 @@ export async function runArchitectureCli(args, io = { write: value => process.st
                     io.write(`Removed ${relative}`);
                     continue;
                 }
-                const prompt = omm ? buildOmmScanPrompt(root, options.language === 'zh' ? 'zh' : 'en') : buildArchitecturePrompt(root, options.language === 'zh' ? 'zh' : 'en');
+                const prompt = await instructions();
                 await fs.writeFile(destination, `---\nname: termdock-architecture\ndescription: Recursively analyze or update this project's Termdock code architecture.\n---\n${marker}\n\n${prompt}\n`, { mode: 0o600 });
                 io.write(`Installed ${relative}`);
             }
@@ -206,10 +223,12 @@ export async function runArchitectureCli(args, io = { write: value => process.st
         }
         if (command === 'validate') {
             const issues = [];
+            if (element)
+                target(document, element);
             for (const view of document.perspectives) {
                 for (const item of [view, ...view.nodes]) {
-                    const key = `${view.id}${item === view ? '' : `/${item.id}`}`;
-                    if (element && !key.startsWith(element))
+                    const key = elementPath(view, item === view ? undefined : item);
+                    if (element && key !== element && !key.startsWith(`${element}/`))
                         continue;
                     if (!item.description && !item.summary)
                         issues.push({ element: key, message: 'Missing description' });
@@ -274,7 +293,13 @@ export async function runArchitectureCli(args, io = { write: value => process.st
             return 0;
         }
         if (command === 'refs') {
-            json({ outgoing: selected.node?.references ?? [], incoming: document.perspectives.flatMap(view => view.nodes.filter(node => node.references?.some(ref => ref.perspective === selected.view.id && (!ref.node || ref.node === selected.node?.id))).map(node => ({ perspective: view.id, node: node.id }))), connections: selected.node ? selected.view.edges.filter(edge => edge.from === selected.node.id || edge.to === selected.node.id) : selected.view.edges });
+            const reference = (perspective, id) => {
+                const view = document.perspectives.find(view => view.id === perspective);
+                const node = id ? view.nodes.find(node => node.id === id) : undefined;
+                return { perspective, ...(id ? { node: id } : {}), element: elementPath(view, node), title: node?.title ?? view.title };
+            };
+            const connections = (selected.node ? selected.view.edges.filter(edge => edge.from === selected.node.id || edge.to === selected.node.id) : selected.view.edges).map(edge => ({ ...edge, fromElement: elementPath(selected.view, selected.view.nodes.find(node => node.id === edge.from)), toElement: elementPath(selected.view, selected.view.nodes.find(node => node.id === edge.to)) }));
+            json({ outgoing: (selected.node?.references ?? []).map(ref => reference(ref.perspective, ref.node)), incoming: document.perspectives.flatMap(view => view.nodes.filter(node => node.references?.some(ref => ref.perspective === selected.view.id && (!ref.node || ref.node === selected.node?.id))).map(node => reference(view.id, node.id))), connections });
             return 0;
         }
         if (command === 'diff') {

package/dist/server/architecture/document.js

@@ -304,19 +304,19 @@ export function buildArchitecturePrompt(root, language, analysis = DEFAULT_ANALY
         'Source paths must be existing files relative to the project root, with no absolute paths, URLs, backslashes or dot/parent segments. Add a positive integer line when verified. Omit uncertain connections and explain uncertainties in summaries.',
         `Write titles, summaries and edge labels in ${language === 'zh' ? 'Chinese' : 'English'}. Set generatedAt to the actual current ISO timestamp. The sample paths are illustrative; use this project's real paths.`,
         'Read the selected output document if it already exists. Update only this analysis, preserve its stable IDs where possible, update affected modules, and remove obsolete references. Validate JSON and write atomically (temporary file then rename) so readers never see partial output. Summarize what was analyzed and any limitations after writing.',
-        `Prefer saving via: td architecture save --project ${JSON.stringify(root)} --file ${JSON.stringify(output)} - (pass the complete JSON on stdin). This validates the document, archives the previous version, and records the update count and Git revision. If the CLI is unavailable, use the atomic file write above and disclose that history metadata was not recorded.`,
+        `Prefer invoking executable td with this argument array: ${JSON.stringify(['architecture', 'save', '--project', root, '--file', output, '-'])}. Pass the complete JSON on stdin. Pass arguments separately; JSON string quoting is not shell escaping. This validates the document, archives the previous version, and records the update count and Git revision. If the CLI is unavailable, use the atomic file write above and disclose that history metadata was not recorded.`,
         JSON.stringify(example, null, 2),
     ].join('\n\n');
 }
 /** Adapted scanner workflow from oh-my-mermaid, MIT; see THIRD_PARTY_NOTICES.md. */
 export function buildOmmScanPrompt(root, language) {
     return [
-        language === 'zh' ? '分析当前项目并递归更新 .omm 架构文档。' : 'Recursively analyze this project and update its .omm architecture documents.',
-        `Project root (literal path): ${JSON.stringify(root)}. Write document content in ${language === 'zh' ? 'Chinese' : 'English'}.`,
+        language.startsWith('zh') ? '分析当前项目并递归更新 .omm 架构文档。' : 'Recursively analyze this project and update its .omm architecture documents.',
+        `Project root (literal path): ${JSON.stringify(root)}. Write document content in language ${JSON.stringify(language)}.`,
         'Read project instructions, manifests, entry points and existing .omm documentation. Select relevant perspectives: overall-architecture, request-lifecycle, data-flow, dependency-map, external-integrations, state-transitions, route-page-map, command-surface, extension-points, pipeline, orchestration, storage.',
         'For each perspective, write a graph LR or graph TD diagram whose node IDs match child directory names (English kebab-case). Every edge must have a meaningful label. Node labels use name plus verified source path separated by \\n. Write description for EVERY node, inspect its actual source, and recursively create child diagrams wherever distinct internal components exist. Leaves still need descriptions. Do not stop at the top-level diagram.',
         'Each element supports description, diagram, context, constraint, concern, todo, note. Use Markdown for text fields. Record real constraints and concerns without inventing them. Existing @perspective references can link between perspectives. Do not rewrite unchanged elements. Remove obsolete references after confirming them. Never modify business source files or include secrets.',
-        `Use the native CLI: td architecture write --project ${JSON.stringify(root)} --format omm <perspective/child/path> <field> - . Supply that field on stdin. Use read, tree, refs and diff to inspect existing documents. Finish with td architecture validate --project ${JSON.stringify(root)} --format omm.`,
+        `Invoke executable td with this argument array: ${JSON.stringify(['architecture', 'write', '--project', root, '--format', 'omm', '<perspective/child/path>', '<field>', '-'])}, replacing the two placeholders with the element path and field. Supply that field on stdin. Pass arguments separately; JSON string quoting is not shell escaping. Use read, tree, refs and diff to inspect existing documents. Finish by invoking td with argument array ${JSON.stringify(['architecture', 'validate', '--project', root, '--format', 'omm'])}.`,
         'Report the inspected sources, updated perspectives, recursion coverage and unresolved limitations. The Termdock architecture viewer reads .omm directly; no separate viewer server is required.',
     ].join('\n\n');
 }

package/dist/server/architecture/documentDiff.js

@@ -2,6 +2,11 @@ import { ARCHITECTURE_FIELDS } from './document.js';
 /** Compare semantic document content, excluding timestamps and update counters. */
 export function diffArchitecture(before, after) {
     const changes = [];
+    if (before) {
+        const changed = ['summary', 'analysis', 'details', 'origin'].filter(key => JSON.stringify(before[key]) !== JSON.stringify(after[key]));
+        if (changed.length)
+            changes.push({ perspective: '', title: 'Project overview', kind: 'changed', fields: changed });
+    }
     const oldViews = new Map(before?.perspectives.map(view => [view.id, view]) ?? []);
     for (const view of after.perspectives) {
         const previous = oldViews.get(view.id);