synabun 1.3.0 → 2.0.0

package/neural-interface/public/shared/cdx/cdx-mcp-app.js

@@ -0,0 +1,178 @@
+// Pure MCP Apps boundaries, shared by the panel, static proxy and server.
+export const APP_RESOURCE_LIMIT = 2 * 1024 * 1024;
+export const APP_MESSAGE_LIMIT = 1024 * 1024;
+export const APP_ARGUMENT_DISPLAY_LIMIT = 64 * 1024;
+export const APP_PROTOCOL_VERSION = '2025-06-18';
+export const APP_OUTER_SANDBOX = 'allow-scripts allow-same-origin allow-forms';
+export const APP_INNER_SANDBOX = 'allow-scripts allow-forms';
+const bytes = value => new TextEncoder().encode(value).length;
+const validBase64 = value => typeof value === 'string' && value.length % 4 === 0
+  && !/[^A-Za-z0-9+/=]/.test(value) && /^(?:[^=]*)(?:={1,2})?$/.test(value)
+  && value.length <= Math.ceil(APP_RESOURCE_LIMIT / 3) * 4;
+export const plainObject = value => !!value && typeof value === 'object' && !Array.isArray(value)
+  && [Object.prototype, null].includes(Object.getPrototypeOf(value));
+
+export function appProxyOrigin(origin) {
+  try {
+    const url = new URL(origin);
+    if (url.protocol !== 'http:' || !['localhost', '127.0.0.1'].includes(url.hostname)) return null;
+    url.hostname = url.hostname === 'localhost' ? '127.0.0.1' : 'localhost';
+    return url.origin;
+  } catch { return null; }
+}
+
+// Reject IP literals entirely (including public ones), ambiguous numeric hosts,
+// local DNS suffixes and wildcards. Exact HTTPS origins only; no DNS resolution.
+export function filterAppDomains(values, ownOrigins = [], limit = 20) {
+  const ownHosts = ownOrigins.flatMap(origin => { try { return [new URL(origin).hostname]; } catch { return []; } });
+  const result = [];
+  for (const value of Array.isArray(values) ? values : []) {
+    if (result.length >= Math.min(20, limit)) break;
+    if (typeof value !== 'string' || value.length > 512 || !/^https:\/\//.test(value)) continue;
+    const raw = value;
+    try {
+      const url = new URL(raw);
+      const host = url.hostname;
+      if (url.protocol !== 'https:' || url.username || url.password || url.search || url.hash || url.pathname !== '/') continue;
+      if (/[\s*]/.test(raw) || !/^[a-z0-9-]+(?:\.[a-z0-9-]+)+$/i.test(host)
+        || host.split('.').some(label => label.startsWith('-') || label.endsWith('-') || label.length > 63)
+        || /(?:^|\.)(?:localhost|local|internal|home|lan|test-local)$/.test(host)
+        || /[\d.]$/.test(host) || host.includes(':')) continue;
+      if (ownHosts.includes(host)) continue;
+      const origin = url.origin;
+      if (!result.includes(origin)) result.push(origin);
+    } catch { /* Reject malformed declarations. */ }
+  }
+  return result;
+}
+
+export function approvedAppCsp(meta = {}, ownOrigins = []) {
+  const connectDomains = filterAppDomains(meta?.csp?.connectDomains, ownOrigins);
+  const resourceDomains = filterAppDomains(meta?.csp?.resourceDomains, ownOrigins, 20 - connectDomains.length);
+  return { connectDomains, resourceDomains };
+}
+
+export function buildAppCsp(csp = {}) {
+  // Refilter even approved inputs: the static proxy never trusts host HTML/CSP.
+  const safe = approvedAppCsp({ csp });
+  const resources = safe.resourceDomains.join(' ');
+  return ["default-src 'none'", `script-src 'unsafe-inline'${resources ? ` ${resources}` : ''}`,
+    `style-src 'unsafe-inline'${resources ? ` ${resources}` : ''}`,
+    `img-src data: blob:${resources ? ` ${resources}` : ''}`,
+    `media-src data: blob:${resources ? ` ${resources}` : ''}`,
+    `font-src data:${resources ? ` ${resources}` : ''}`,
+    `connect-src ${safe.connectDomains.length ? safe.connectDomains.join(' ') : "'none'"}`,
+    "frame-src 'none'", "object-src 'none'", "base-uri 'none'", "form-action 'none'", "webrtc 'block'"].join('; ');
+}
+
+export function buildAppSrcdoc(html, csp = {}) {
+  if (typeof html !== 'string' || bytes(html) > APP_RESOURCE_LIMIT) throw new Error('App resource exceeds 2 MB.');
+  const policy = buildAppCsp(csp).replaceAll('&', '&amp;').replaceAll('"', '&quot;').replaceAll('<', '&lt;');
+  // The first policy is enforced even if later resource bytes contain their own
+  // doctype, head, CSP or base. Later policies can only restrict it further.
+  return `<!doctype html><html><head><meta http-equiv="Content-Security-Policy" content="${policy}"><meta http-equiv="x-dns-prefetch-control" content="off"></head><body>${html}</body></html>`;
+}
+
+// The complete display is also the immutable JSON snapshot approved for sending.
+export function appArgumentDisplay(value = {}) {
+  if (!plainObject(value)) throw new Error('Tool arguments must be an object.');
+  const text = JSON.stringify(value, null, 2);
+  const size = bytes(text);
+  if (size > APP_ARGUMENT_DISPLAY_LIMIT) throw new Error('Tool arguments exceed the 64 KiB display cap.');
+  return { text, size, arguments: JSON.parse(text) };
+}
+
+export function decodedAppContent(content) {
+  if (!plainObject(content) || typeof content.uri !== 'string') throw new Error('Invalid resource content.');
+  if (typeof content.text === 'string' && content.blob == null) {
+    if (bytes(content.text) > APP_RESOURCE_LIMIT) throw new Error('Resource exceeds 2 MB.');
+    return content.text;
+  }
+  if (!validBase64(content.blob) || content.text != null) throw new Error('Invalid resource blob.');
+  const decoded = Uint8Array.from(atob(content.blob), char => char.charCodeAt(0));
+  if (decoded.length > APP_RESOURCE_LIMIT) throw new Error('Resource exceeds 2 MB.');
+  return new TextDecoder('utf-8', { fatal: true }).decode(decoded);
+}
+
+export function acceptAppResource(result, uri) {
+  if (typeof uri !== 'string' || !uri.startsWith('ui://')) throw new Error('App resources require ui://.');
+  const content = result?.contents?.find(entry => entry?.uri === uri);
+  if (content?.mimeType !== 'text/html;profile=mcp-app') throw new Error('Resource is not an MCP app.');
+  return { html: decodedAppContent(content), meta: plainObject(content._meta?.ui) ? content._meta.ui : {} };
+}
+
+export function validateAppResources(result) {
+  if (!Array.isArray(result?.contents)) throw new Error('Invalid resource response.');
+  let size = 0;
+  for (const content of result.contents) {
+    if (!plainObject(content) || typeof content.uri !== 'string') throw new Error('Invalid resource content.');
+    // Blob resources need not be UTF-8 for resources/read, but are still capped.
+    if (typeof content?.blob === 'string') {
+      if (content.text != null || !validBase64(content.blob)) throw new Error('Invalid resource blob.');
+      size += atob(content.blob).length;
+    } else size += bytes(decodedAppContent(content));
+    if (size > APP_RESOURCE_LIMIT) throw new Error('Resources exceed 2 MB.');
+  }
+  return result;
+}
+
+export function validAppMessage(message) {
+  if (!plainObject(message) || message.jsonrpc !== '2.0') return false;
+  if ('id' in message && !(typeof message.id === 'string' && message.id.length <= 256)
+    && !(typeof message.id === 'number' && Number.isFinite(message.id))) return false;
+  if (typeof message.method !== 'string' || !message.method || message.method.length > 100) return false;
+  try { if (bytes(JSON.stringify(message.params ?? {})) > APP_MESSAGE_LIMIT) return false; } catch { return false; }
+  return true;
+}
+
+export function validAppEvent(event, source, origin) {
+  return event.source === source && event.origin === origin && validAppMessage(event.data);
+}
+
+export function validAppResponse(message, limit = APP_MESSAGE_LIMIT) {
+  if (!plainObject(message) || message.jsonrpc !== '2.0' || 'method' in message
+    || !(typeof message.id === 'string' && message.id.length <= 256 || typeof message.id === 'number' && Number.isFinite(message.id))
+    || !('result' in message || 'error' in message)) return false;
+  try { return bytes(JSON.stringify(message)) <= limit; } catch { return false; }
+}
+
+export const APP_METHOD_ROUTES = Object.freeze({
+  'ui/initialize': 'initialize', 'ui/notifications/initialized': 'initialized',
+  'tools/call': 'approve-tool', 'resources/read': 'read-resource',
+  'ui/open-link': 'approve-link', 'ui/message': 'draft',
+  'ui/notifications/size-changed': 'resize', 'ui/notifications/request-teardown': 'teardown',
+  'notifications/message': 'log', ping: 'ping', 'ui/request-display-mode': 'display-mode',
+});
+export const appMethodRoute = method => Object.hasOwn(APP_METHOD_ROUTES, method) ? APP_METHOD_ROUTES[method] : 'unsupported';
+
+export function createAppCallGate({ now = Date.now, limit = 5, interval = 10000 } = {}) {
+  let pending = null, inFlight = false, hits = [];
+  const rate = () => {
+    const time = now(); hits = hits.filter(hit => time - hit < interval);
+    if (hits.length >= limit) return false;
+    hits.push(time); return true;
+  };
+  return {
+    offer(call) { if (pending || inFlight || !rate()) return false; pending = call; return true; },
+    decline() { const call = pending; pending = null; return call; },
+    async allow(bridge) {
+      if (!pending || inFlight) throw new Error('Explicit approval required.');
+      const call = pending; pending = null; inFlight = true;
+      try { return await bridge(call); } finally { inFlight = false; }
+    },
+    rate,
+  };
+}
+
+export function appToolOutcome(item) {
+  const status = typeof item?.status === 'string' ? item.status : Object.keys(item?.status || {})[0];
+  if (/failed|declined|cancel|error/i.test(status || '') || item?.error) return { method: 'ui/notifications/tool-cancelled', params: { reason: 'Tool call failed or was declined.' } };
+  if (!/^(completed|complete|done|success)$/.test(status || '') && !item?._synabunCompleted) return null;
+  const result = item?.result;
+  return { method: 'ui/notifications/tool-result', params: {
+    content: Array.isArray(result?.content) ? result.content : [],
+    ...(result?.structuredContent != null ? { structuredContent: result.structuredContent } : {}),
+    ...(typeof result?.isError === 'boolean' ? { isError: result.isError } : {}),
+    ...(plainObject(result?._meta) ? { _meta: result._meta } : {}),
+  } };
+}

package/neural-interface/public/shared/cdx/cdx-model-catalog.js

@@ -0,0 +1,120 @@
+import { getCodexModelName, mergeCodexModelOptions } from '../agent-runtime-options.js';
+import { codexModelAccessMetadata } from './cdx-protocol.js';
+
+export const codexModelAccountKey = tab => String(tab?.accountId || 'default');
+
+// Only successful live discovery supplies capabilities. Fallback choices are
+// presentation data and must never turn a failed request into a cache hit.
+export class CodexModelCatalog {
+  constructor({ request, isReady, onChange = () => {} }) {
+    this.requestModels = request;
+    this.isReady = isReady;
+    this.onChange = onChange;
+    this.accounts = new Map();
+  }
+
+  state(tab) {
+    const key = codexModelAccountKey(tab);
+    if (!this.accounts.has(key)) {
+      this.accounts.set(key, { status: 'idle', models: null, error: '', pending: null });
+    }
+    return this.accounts.get(key);
+  }
+
+  choices(tab) {
+    return this.state(tab).models ?? mergeCodexModelOptions([]);
+  }
+
+  invalidate(tab) {
+    const state = this.state(tab);
+    const pending = state.pending;
+    state.pending = null;
+    state.status = 'idle';
+    state.error = '';
+    pending?.controller.abort();
+    this.onChange(codexModelAccountKey(tab));
+  }
+
+  disconnect(tab) {
+    // A different tab on the same account may still own a valid request.
+    if (this.state(tab).pending?.tab === tab) this.invalidate(tab);
+  }
+
+  request(tab, { force = false } = {}) {
+    if (!tab || tab.closed) return Promise.resolve([]);
+    const account = codexModelAccountKey(tab);
+    const state = this.state(tab);
+    if (!this.isReady(tab)) {
+      this.disconnect(tab);
+      return Promise.resolve(this.choices(tab));
+    }
+    const previous = state.pending;
+    if (previous?.isCurrent() && (!force || previous.tab === tab)) return previous.promise;
+    if (!force && state.status === 'ready') return Promise.resolve(this.choices(tab));
+
+    const epoch = tab.connectionEpoch;
+    const socket = tab.ws;
+    const pending = { tab, controller: new AbortController() };
+    pending.isCurrent = () => state.pending === pending
+      && codexModelAccountKey(tab) === account
+      && tab.connectionEpoch === epoch && tab.ws === socket && this.isReady(tab);
+    state.pending = pending;
+    state.status = 'loading';
+    state.error = '';
+    previous?.controller.abort();
+    // Register the transport request before the ready callback can release an
+    // inactive tab's idle socket. The response still settles asynchronously.
+    let response;
+    try { response = this.requestModels(tab, pending.controller.signal); }
+    catch (error) { response = Promise.reject(error); }
+    pending.promise = Promise.resolve(response)
+      .then(message => {
+        if (!pending.isCurrent()) return;
+        if (message?.error) throw new Error(message.error);
+        if (!Array.isArray(message?.models)) throw new Error('Codex returned an invalid model list.');
+        state.models = mergeCodexModelOptions(message.models, { fallback: false }).map(option => {
+          const native = message.models.find(model => getCodexModelName(model) === option.id);
+          return { ...option, availableAccessPrograms: native?.availableAccessPrograms || null,
+            desc: [option.desc, codexModelAccessMetadata(native)].filter(Boolean).join(' · ') };
+        });
+        state.status = 'ready';
+      })
+      .catch(error => {
+        if (!pending.isCurrent()) return;
+        state.status = 'error';
+        state.error = error?.message || 'Could not load model capabilities.';
+      })
+      .finally(() => {
+        if (state.pending !== pending) return;
+        state.pending = null;
+        // A closed or replaced connection cannot leave the account loading.
+        if (state.status === 'loading') state.status = 'idle';
+        this.onChange(account);
+      })
+      .then(() => this.choices(tab));
+    this.onChange(account);
+    return pending.promise;
+  }
+}
+
+export function codexContextAvailability({ tab, catalog, model, connected }) {
+  if (!tab) return { supported: false, reason: 'Open a Codex conversation first.', retry: false };
+  const baseline = Number(model?.contextWindow), maximum = Number(model?.maxContextWindow);
+  const complete = Number.isFinite(baseline) && baseline > 0 && Number.isFinite(maximum) && maximum >= baseline;
+  const supported = catalog.status === 'ready' && complete && maximum > baseline && model?.supportsExtendedContext === true;
+  let reason = '', retry = false;
+  if (!connected) reason = 'Waiting for the Codex connection to load model capabilities.';
+  else if (catalog.status === 'idle' || catalog.status === 'loading') reason = 'Loading model capabilities…';
+  else if (catalog.status === 'error') {
+    reason = 'Could not load model capabilities. Retry to check extended context.';
+    retry = true;
+  } else if (!model) reason = 'The selected model is not in this account’s current model list.';
+  else if (!complete) {
+    reason = 'Codex has not reported context capabilities for this model. Retry to check again.';
+    retry = true;
+  } else if (!supported) reason = 'Extended context is not advertised for the selected model and account.';
+  const busy = tab.compacting ? 'Wait for compaction to finish before changing context.'
+    : tab.startingThread ? 'Wait for the conversation to start before changing context.'
+      : tab.running ? 'Wait for the current reply to finish before changing context.' : '';
+  return { supported: supported && connected, reason: busy || reason, retry, busy: !!busy };
+}

package/neural-interface/public/shared/cdx/cdx-output-model.js

@@ -0,0 +1,261 @@
+// Pure, bounded presentation logic shared by assistant answers and tool cards.
+export const OUTPUT_LIMITS = Object.freeze({ input: 200000, raw: 24000, unbrokenRun: 512, pathChars: 60, value: 8000, nodes: 2000, depth: 4, array: 12, diffPreview: 60, diffLines: 2000, files: 100 });
+
+export function boundedText(value, limit = OUTPUT_LIMITS.raw) {
+  const text = String(value ?? '');
+  return text.length > limit ? `${text.slice(0, limit)}\n… Truncated (${text.length.toLocaleString()} characters; showing ${limit.toLocaleString()}).` : text;
+}
+
+export function jsonAnswer(text) {
+  const original = String(text ?? '');
+  if (original.length > OUTPUT_LIMITS.input) return { kind: 'oversized', raw: boundedText(original) };
+  let source = original.trim();
+  if (!/^[{[]/.test(source)) return null;
+  try {
+    const value = JSON.parse(source);
+    if (!value || typeof value !== 'object') return null;
+    return { kind: 'json', value, raw: source };
+  } catch { return null; }
+}
+
+export function looksLikeStreamingJson(text) {
+  const source = String(text ?? '').trimStart();
+  return /^\{/.test(source) || /^\[\s*(?:[\[{"\d-]|true\b|false\b|null\b|$)/.test(source);
+}
+
+export function prettyJsonFences(text) {
+  const source = String(text ?? '');
+  if (source.length > OUTPUT_LIMITS.input) return boundedText(source);
+  return source.replace(/^(`{3,}|~{3,})(json)?[ \t]*\r?\n([\s\S]*?)\r?\n\1[ \t]*$/gim, (whole, fence, tag, body) => {
+    const parsed = jsonAnswer(body);
+    return parsed?.kind === 'json' ? `${fence}${tag || ''}\n${readableStructuredValue(parsed.value)}\n${fence}` : whole;
+  });
+}
+
+// Bound tokens, hashes and other whitespace-free runs without changing wordy prose.
+export function hasOverlongRun(text) {
+  return new RegExp(`\\S{${OUTPUT_LIMITS.unbrokenRun + 1},}`).test(String(text ?? '').slice(0, OUTPUT_LIMITS.input));
+}
+
+export function outputOverflows(scrollHeight, clientHeight) {
+  return clientHeight > 0 && scrollHeight > clientHeight + 1;
+}
+
+export function displayDiffPath(path, cwd = '', maxChars = OUTPUT_LIMITS.pathChars) {
+  const full = String(path ?? '');
+  const directory = String(cwd || '').replace(/\\/g, '/').replace(/\/$/, '');
+  const normalized = full.replace(/\\/g, '/');
+  const sameRoot = /^[A-Z]:/i.test(directory) ? normalized.toLowerCase().startsWith(directory.toLowerCase() + '/') : normalized.startsWith(directory + '/');
+  const relative = directory && sameRoot ? normalized.slice(directory.length + 1) : full;
+  if (relative.length <= maxChars) return relative;
+  const slash = Math.max(relative.lastIndexOf('/'), relative.lastIndexOf('\\'));
+  const filename = relative.slice(slash + 1);
+  if (slash < 0) return relative; // Never cut a filename, even in a very narrow panel.
+  const tail = '/' + filename;
+  const room = Math.max(0, maxChars - tail.length - 1);
+  const prefix = Math.ceil(room / 2), suffix = Math.floor(room / 2);
+  return relative.slice(0, prefix) + '…' + (suffix ? relative.slice(slash - suffix, slash) : '') + tail;
+}
+
+// Several consecutive matching lines; never match ordinary lists/headings/fences.
+export function isPreformattedText(text) {
+  const source = String(text ?? '').slice(0, OUTPUT_LIMITS.input);
+  if (/^\s*(?:```|~~~)/m.test(source)) return false;
+  const lines = source.split(/\r?\n/);
+  const patterns = [
+    line => /^\s*[│├└]─?|^\s*[│ ]*[├└]──/.test(line),
+    line => /^\s+(?:at\s+\S|File "|\S+Error:)|^\s*\S+\.(?:js|py|ts):\d+/.test(line),
+    line => /^(?:\[?\d{2}:\d{2}:\d{2}|\d{4}-\d\d-\d\d[T ]|\[(?:INFO|WARN|ERROR|DEBUG)\]|(?:INFO|WARN|ERROR|DEBUG)\b)/.test(line),
+    line => /^[\w./-]+:[ \t]*(?:\S.*)?$/.test(line),
+    line => /^(?: {4,}|\t)\S/.test(line) && !/^\s*(?:[-*+] |\d+[.)] )/.test(line),
+    line => /\S[ \t]{2,}\S.*\S[ \t]{2,}\S/.test(line) && !/^\s*(?:[-*+>#]|\d+[.)] )/.test(line),
+  ];
+  if (patterns.some(matches => {
+    let consecutive = 0;
+    return lines.some(line => { consecutive = matches(line) ? consecutive + 1 : 0; return consecutive >= 3; });
+  })) return true;
+  let offset = -1, consecutive = 0;
+  return lines.some(line => {
+    const columns = line.match(/^(\S+)[ \t]{2,}([\w./:+-]+(?:[ \t][\w./:+-]+)*)$/);
+    const next = columns ? columns[1].length : -1;
+    consecutive = next >= 0 ? next === offset ? consecutive + 1 : 1 : 0;
+    offset = next;
+    return consecutive >= 3;
+  });
+}
+
+export function cleanTerminal(value) {
+  let text = String(value ?? '');
+  const oversized = text.length > OUTPUT_LIMITS.input;
+  text = text.slice(0, OUTPUT_LIMITS.input)
+    // OSC (including links), DCS/PM/APC, CSI, and single-character escapes.
+    .replace(/(?:\x1b\]|\x9d)[\s\S]*?(?:\x07|\x1b\\|\x9c|$)/g, '')
+    .replace(/\x1b[P^_][\s\S]*?(?:\x1b\\|$)/g, '')
+    .replace(/(?:\x1b\[|\x9b)[0-?]*[ -/]*[@-~]/g, '')
+    .replace(/\x1b(?:[()][0-2A-Z]|[ -/]*[@-~])/g, '')
+    .replace(/\r\n/g, '\n');
+  const result = [];
+  let line = [];
+  let carriage = false;
+  for (const char of text) {
+    if (char === '\r') carriage = true;
+    else if (char === '\b') line.pop();
+    else if (char === '\n') { result.push(line.join('')); line = []; carriage = false; }
+    else if (char === '\t' || char >= ' ' && !/[\x7f-\x9f]/.test(char)) { if (carriage) { line = []; carriage = false; } line.push(char); }
+  }
+  result.push(line.join(''));
+  return result.join('\n') + (oversized ? '\n… Terminal input truncated at 200,000 characters.' : '');
+}
+
+// Build a model before making DOM nodes. A global budget handles wide/deep payloads.
+export function structuredValueModel(input) {
+  let value = input;
+  const parsed = typeof input === 'string' ? jsonAnswer(input) : null;
+  if (parsed?.kind === 'oversized') return { kind: 'raw', text: parsed.raw };
+  if (parsed?.kind === 'json') value = parsed.value;
+  let budget = OUTPUT_LIMITS.nodes;
+  const seen = new Set();
+  const build = (entry, depth) => {
+    if (--budget < 0) return { kind: 'raw', text: '… Structure truncated at 2,000 values.' };
+    if (entry === null || typeof entry !== 'object') return { kind: 'scalar', type: entry === null ? 'null' : typeof entry, text: boundedText(entry === null ? 'null' : entry === '' ? '""' : entry, OUTPUT_LIMITS.value) };
+    if (seen.has(entry)) return { kind: 'raw', text: '[Circular reference]' };
+    seen.add(entry);
+    if (depth >= OUTPUT_LIMITS.depth) {
+      // Bounded iterative copy avoids JSON.stringify on an arbitrarily deep object.
+      return { kind: 'raw', text: readableStructuredValue(entry, OUTPUT_LIMITS.raw) };
+    }
+    const array = Array.isArray(entry);
+    const keys = array ? null : Object.keys(entry);
+    const total = array ? entry.length : keys.length;
+    const entries = [];
+    for (let i = 0; i < total && budget > 0; i++) {
+      const key = array ? i : keys[i];
+      entries.push({ key: boundedText(String(key), 1000), value: build(entry[key], depth + 1) });
+    }
+    seen.delete(entry);
+    return { kind: array ? 'array' : 'object', entries, total, truncated: entries.length < total };
+  };
+  return build(value, 0);
+}
+
+export function readableStructuredValue(value, limit = OUTPUT_LIMITS.raw) {
+  if (typeof value === 'string') {
+    const parsed = jsonAnswer(value);
+    if (parsed?.kind === 'json') value = parsed.value;
+    else return boundedText(cleanTerminal(value), limit);
+  }
+  // Iterative traversal bounds depth, size, cycles and even huge individual strings.
+  let count = 0;
+  let characters = OUTPUT_LIMITS.raw * 2;
+  const seen = new Set();
+  const clone = entry => {
+    if (++count > OUTPUT_LIMITS.nodes) return '… Structure truncated';
+    if (typeof entry === 'string') {
+      if (characters <= 0) return '… Output truncated';
+      const cap = Math.min(OUTPUT_LIMITS.value, characters);
+      const text = cleanTerminal(boundedText(entry, cap));
+      characters -= Math.min(entry.length, cap);
+      return text;
+    }
+    if (!entry || typeof entry !== 'object') return entry ?? null;
+    if (seen.has(entry)) return '[Circular reference]';
+    seen.add(entry);
+    return Array.isArray(entry) ? [] : {};
+  };
+  const root = clone(value);
+  const work = value && typeof value === 'object' ? [{ src: value, dst: root, depth: 0 }] : [];
+  while (work.length && count <= OUTPUT_LIMITS.nodes) {
+    const { src, dst, depth } = work.pop();
+    for (const key of Object.keys(src)) {
+      if (count > OUTPUT_LIMITS.nodes) break;
+      const entry = src[key];
+      const child = depth >= 12 && entry && typeof entry === 'object' ? '[Depth limit]' : clone(entry);
+      // DefineProperty treats __proto__ as data.
+      Object.defineProperty(dst, key, { value: child, enumerable: true, configurable: true, writable: true });
+      if (entry && typeof entry === 'object' && child && typeof child === 'object') work.push({ src: entry, dst: child, depth: depth + 1 });
+    }
+  }
+  try { return boundedText(JSON.stringify(root, null, 2), limit); }
+  catch { return '[Unrenderable value]'; }
+}
+
+function patchPath(text, stripPrefix = true) {
+  let path = String(text || '').split('\t')[0].trim();
+  if (path.startsWith('"')) { try { path = JSON.parse(path); } catch {} }
+  return stripPrefix ? path.replace(/^[ab]\//, '') : path;
+}
+
+export function parseUnifiedDiff(input, fallback = {}) {
+  const raw = String(input ?? '');
+  if (raw.length > OUTPUT_LIMITS.input) return [{ ...fallback, path: fallback.path || 'Oversized patch', status: fallback.status || 'modified', lines: [], hunks: [], added: 0, removed: 0, oversized: true, raw }];
+  const files = [];
+  let file = null, oldLine = null, newLine = null, inHunk = false, oldRemaining = 0, newRemaining = 0;
+  const begin = (path = fallback.path || 'Changes') => {
+    file = { path, oldPath: fallback.oldPath || path, status: fallback.status || 'modified', lines: [], hunks: [], added: 0, removed: 0, raw: '' };
+    files.push(file); oldLine = newLine = null; inHunk = false;
+  };
+  for (const line of raw.replace(/\r\n/g, '\n').split('\n')) {
+    if (line.startsWith('diff --git ')) {
+      if (files.length >= OUTPUT_LIMITS.files) { files[files.length - 1].filesTruncated = true; break; }
+      const paths = line.slice(11).match(/"(?:[^"\\]|\\.)*"|\S+/g) || [];
+      begin(patchPath(paths[1] || paths[0])); file.oldPath = patchPath(paths[0]);
+    } else if (!file) begin();
+    else if (line.startsWith('--- ') && !inHunk && file.hunks.length) begin();
+    file.raw += `${line}\n`;
+    if (/^(?:Binary files |GIT binary patch)/.test(line)) { file.binary = true; inHunk = false; }
+    else if (line.startsWith('new file mode ')) file.status = 'added';
+    else if (line.startsWith('deleted file mode ')) file.status = 'deleted';
+    else if (line.startsWith('rename from ')) { file.oldPath = patchPath(line.slice(12), false); file.status = 'renamed'; }
+    else if (line.startsWith('rename to ')) { file.path = patchPath(line.slice(10), false); file.status = 'renamed'; }
+    else if (!inHunk && line.startsWith('--- ')) { file.oldPath = patchPath(line.slice(4)); if (file.oldPath === '/dev/null') file.status = 'added'; }
+    else if (!inHunk && line.startsWith('+++ ')) { file.path = patchPath(line.slice(4)); if (file.path === '/dev/null') { file.path = file.oldPath; file.status = 'deleted'; } }
+    else {
+      const hunk = line.match(/^@@ -(\d+)(?:,(\d+))? \+(\d+)(?:,(\d+))? @@/);
+      if (hunk) { oldLine = +hunk[1]; newLine = +hunk[3]; oldRemaining = +(hunk[2] ?? 1); newRemaining = +(hunk[4] ?? 1); inHunk = true; file.hunks.push({oldStart: oldLine, newStart: newLine}); }
+      let row;
+      if (hunk) row = { kind: 'hunk', sign: ' ', text: line };
+      else if (line === '\') row = { kind: 'note', sign: ' ', text: line };
+      else if (inHunk && /^[ +\-]/.test(line)) {
+        const sign = line[0];
+        row = { kind: sign === '+' ? 'add' : sign === '-' ? 'delete' : 'context', sign, text: line.slice(1), oldLine: sign === '+' ? null : oldLine++, newLine: sign === '-' ? null : newLine++ };
+        if (sign === '+') file.added++;
+        if (sign === '-') file.removed++;
+        if (sign !== '+') oldRemaining--;
+        if (sign !== '-') newRemaining--;
+        if (oldRemaining <= 0 && newRemaining <= 0) inHunk = false;
+      }
+      if (row) { if (file.lines.length < OUTPUT_LIMITS.diffLines) file.lines.push(row); else file.oversized = true; }
+    }
+  }
+  return files.filter(entry => entry.raw.trim());
+}
+
+export function fileChangeDiffs(item = {}) {
+  const changes = Array.isArray(item.changes) ? item.changes : [];
+  const raw = typeof item.aggregatedOutput === 'string' ? item.aggregatedOutput : '';
+  if (raw && (/^(?:diff --git |--- )/m.test(raw) || changes.length <= 1 && /^@@ /m.test(raw))) return parseUnifiedDiff(raw, changes.length === 1 ? changeInfo(changes[0]) : {});
+  const files = changes.slice(0, OUTPUT_LIMITS.files).flatMap(change => {
+    const info = changeInfo(change);
+    const patch = change.diff || change.patch || change.content || change.output || '';
+    if (!patch) return [{ ...info, lines: [], hunks: [], added: 0, removed: 0, raw: '', unavailable: true }];
+    return parseUnifiedDiff(typeof patch === 'string' ? patch : readableStructuredValue(patch), info);
+  });
+  if (changes.length > OUTPUT_LIMITS.files && files.length) files[files.length - 1].filesTruncated = true;
+  return files;
+}
+
+function changeInfo(change) {
+  const kind = typeof change.kind === 'object' ? change.kind : { type: change.kind || change.type };
+  const moved = kind.move_path || kind.movePath || change.newPath;
+  const path = change.path || change.filePath || 'Changes';
+  return { path: moved || path, oldPath: path, status: moved ? 'renamed' : /^(add|added)$/.test(kind.type) ? 'added' : /^(delete|deleted)$/.test(kind.type) ? 'deleted' : 'modified' };
+}
+
+export function diffFingerprint(file) {
+  return JSON.stringify([file.path, file.oldPath, file.status, !!file.binary, file.lines.filter(line => line.kind !== 'hunk').map(line => [line.sign, line.text])]);
+}
+
+export function deduplicateTurnDiff(files, shown) {
+  const fingerprints = new Set(shown.filter(file => !file.oversized && !file.unavailable).map(diffFingerprint));
+  return files.filter(file => file.oversized || !fingerprints.has(diffFingerprint(file)));
+}