@datalayer/agent-runtimes 1.5.33 → 1.5.34

package/lib/apps/plugins/shield-displays/DiffCard.d.ts

@@ -0,0 +1,17 @@
+/**
+ * What a coding agent changed in one file, as a unified diff (SHIELD §4.3,
+ * SH-16): the path and the count in the header, each line signed and
+ * coloured, the file's language on the block for a highlighter. What it
+ * reads is `portable/displays`' (`protocolDisplayOf`, `unifiedDiffLines`),
+ * so the phone draws the same thing from the same contract.
+ *
+ * @module apps/plugins/shield-displays/DiffCard
+ */
+import type { JSX } from 'react';
+import { type ProtocolDisplay } from '../../../portable';
+export type DiffCardProps = {
+    display: Extract<ProtocolDisplay, {
+        kind: 'diff';
+    }>;
+};
+export declare function DiffCard({ display }: DiffCardProps): JSX.Element;

package/lib/apps/plugins/shield-displays/DiffCard.js

@@ -0,0 +1,34 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Text } from '@primer/react';
+import { Box } from '@datalayer/primer-addons';
+import { displayLine, unifiedDiffLines, } from '../../../portable';
+const COLOURS = {
+    context: { bg: 'transparent', fg: 'fg.muted', sign: ' ' },
+    add: { bg: 'success.subtle', fg: 'success.fg', sign: '+' },
+    remove: { bg: 'danger.subtle', fg: 'danger.fg', sign: '-' },
+};
+export function DiffCard({ display }) {
+    const lines = unifiedDiffLines(display.oldText, display.newText);
+    return (_jsxs(Box, { "data-shield-display": "diff", "data-language": display.language, sx: {
+            width: '100%',
+            border: '1px solid',
+            borderColor: 'border.default',
+            borderRadius: 2,
+            overflow: 'hidden',
+            fontSize: 0,
+        }, children: [_jsxs(Box, { sx: {
+                    px: 2,
+                    py: 1,
+                    bg: 'canvas.subtle',
+                    borderBottom: '1px solid',
+                    borderColor: 'border.default',
+                    display: 'flex',
+                    justifyContent: 'space-between',
+                }, children: [_jsx(Text, { sx: { fontFamily: 'mono', fontWeight: 'bold' }, children: display.path }), _jsx(Text, { sx: { color: 'fg.muted' }, children: displayLine(display) })] }), _jsx(Box, { as: "pre", className: `language-${display.language}`, sx: { m: 0, overflowX: 'auto', fontFamily: 'mono' }, children: lines.map((line, index) => (_jsxs(Box, { as: "span", "data-diff-line": line.kind, sx: {
+                        display: 'block',
+                        px: 2,
+                        bg: COLOURS[line.kind].bg,
+                        color: COLOURS[line.kind].fg,
+                        whiteSpace: 'pre',
+                    }, children: [COLOURS[line.kind].sign, line.text] }, index))) })] }));
+}

package/lib/apps/plugins/shield-displays/TerminalCard.d.ts

@@ -0,0 +1,16 @@
+/**
+ * What a coding agent ran (SHIELD §4.3, SH-16): the command in the header,
+ * the output kept after the terminal was released, and how it ended — the
+ * exit code, or *running* while it runs. What it reads is
+ * `portable/displays`' (`protocolDisplayOf`), the phone's contract too.
+ *
+ * @module apps/plugins/shield-displays/TerminalCard
+ */
+import type { JSX } from 'react';
+import { type ProtocolDisplay } from '../../../portable';
+export type TerminalCardProps = {
+    display: Extract<ProtocolDisplay, {
+        kind: 'terminal';
+    }>;
+};
+export declare function TerminalCard({ display }: TerminalCardProps): JSX.Element;

package/lib/apps/plugins/shield-displays/TerminalCard.js

@@ -0,0 +1,31 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Text } from '@primer/react';
+import { Box } from '@datalayer/primer-addons';
+import { displayLine } from '../../../portable';
+export function TerminalCard({ display }) {
+    const failed = display.exitCode !== null && display.exitCode !== 0;
+    return (_jsxs(Box, { "data-shield-display": "terminal", "data-exit-code": display.exitCode === null ? 'running' : display.exitCode, sx: {
+            width: '100%',
+            border: '1px solid',
+            borderColor: failed ? 'danger.muted' : 'border.default',
+            borderRadius: 2,
+            overflow: 'hidden',
+            fontSize: 0,
+        }, children: [_jsxs(Box, { sx: {
+                    px: 2,
+                    py: 1,
+                    bg: 'canvas.subtle',
+                    borderBottom: '1px solid',
+                    borderColor: 'border.default',
+                    display: 'flex',
+                    justifyContent: 'space-between',
+                }, children: [_jsx(Text, { sx: { fontFamily: 'mono', fontWeight: 'bold' }, children: display.command ? `$ ${display.command}` : display.terminalId }), _jsx(Text, { sx: { color: failed ? 'danger.fg' : 'fg.muted' }, children: displayLine(display) })] }), _jsx(Box, { as: "pre", sx: {
+                    m: 0,
+                    px: 2,
+                    py: 1,
+                    overflowX: 'auto',
+                    fontFamily: 'mono',
+                    whiteSpace: 'pre-wrap',
+                    bg: 'canvas.default',
+                }, children: display.output || (display.exitCode === null ? '…' : '(no output)') })] }));
+}

package/lib/apps/plugins/shield-displays/index.d.ts

@@ -0,0 +1,9 @@
+import type { ReactorPlugin } from '@datalayer/reactor';
+export declare const SHIELD_DISPLAYS_PLUGIN_NAME = "@datalayer/loop-plugin-shield-displays";
+/** The plugin: two renderers, no tool binding. */
+export declare function createShieldDisplaysPlugin(): ReactorPlugin<Record<string, never>, unknown, unknown>;
+/** The instance the preset mounts. */
+export declare const ShieldDisplaysPlugin: ReactorPlugin<Record<string, never>, unknown, unknown>;
+export { DiffCard, type DiffCardProps } from './DiffCard';
+export { TerminalCard, type TerminalCardProps } from './TerminalCard';
+export default ShieldDisplaysPlugin;

package/lib/apps/plugins/shield-displays/index.js

@@ -0,0 +1,63 @@
+/*
+ * Copyright (c) 2025-2026 Datalayer, Inc.
+ * Distributed under the terms of the Modified BSD License.
+ */
+/**
+ * `@datalayer/loop-plugin-shield-displays` — a coding agent's *diff* and
+ * *terminal*, drawn where its tool results carry them (SHIELD §4.3, SH-16).
+ *
+ * The runtime sends each beside the tool's result in
+ * `_meta["reactor.ui/display"]`, as every protocol display travels
+ * (REACTOR_UI RU-1): `application/vnd.datalayer.shield.diff+json` and
+ * `application/vnd.datalayer.shield.terminal+json`, typed in Python as
+ * `agent_runtimes.adapters.harness_displays`. This plugin contributes one
+ * renderer per type; it binds no tool, since a harness names its tools as it
+ * likes (*Edit hello.py*, *Run pytest*) and the display is what says what
+ * it is. The web chat and the embed mount it through the preset; the phone
+ * reads the same contract from `portable/displays` (MOBILE M-037).
+ *
+ * @module apps/plugins/shield-displays
+ */
+import { createElement } from 'react';
+import { contribution, definePlugin } from '@datalayer/reactor';
+import { Renderers } from '@datalayer/reactor/ui';
+import { defineRenderer, } from '@datalayer/reactor/ui/react';
+import { protocolDisplayOf, SHIELD_DIFF_TYPE, SHIELD_TERMINAL_TYPE, } from '../../../portable';
+import { DiffCard } from './DiffCard';
+import { TerminalCard } from './TerminalCard';
+export const SHIELD_DISPLAYS_PLUGIN_NAME = '@datalayer/loop-plugin-shield-displays';
+function Diff({ display, context, }) {
+    const read = protocolDisplayOf(display);
+    if (!read || read.kind !== 'diff') {
+        // Does not read as a diff: the chat's own row says what it can.
+        return createElement('span', null, context?.defaultUI ?? display.text);
+    }
+    return createElement(DiffCard, { key: display.id, display: read });
+}
+function Terminal({ display, context, }) {
+    const read = protocolDisplayOf(display);
+    if (!read || read.kind !== 'terminal') {
+        return createElement('span', null, context?.defaultUI ?? display.text);
+    }
+    return createElement(TerminalCard, { key: display.id, display: read });
+}
+/** The plugin: two renderers, no tool binding. */
+export function createShieldDisplaysPlugin() {
+    const plugin = definePlugin({
+        name: SHIELD_DISPLAYS_PLUGIN_NAME,
+        displayName: 'Diffs and terminals',
+        description: 'What a coding agent changed, as a unified diff, and what it ran, with its output.',
+        octicon: 'diff',
+        emoji: '\u{1F6E1}',
+        contributes: [
+            contribution(Renderers, defineRenderer({ type: SHIELD_DIFF_TYPE, component: Diff }), { id: 'shield-diff' }),
+            contribution(Renderers, defineRenderer({ type: SHIELD_TERMINAL_TYPE, component: Terminal }), { id: 'shield-terminal' }),
+        ],
+    });
+    return plugin;
+}
+/** The instance the preset mounts. */
+export const ShieldDisplaysPlugin = createShieldDisplaysPlugin();
+export { DiffCard } from './DiffCard';
+export { TerminalCard } from './TerminalCard';
+export default ShieldDisplaysPlugin;

package/lib/apps/presets.js

@@ -40,6 +40,7 @@ import { ChatPlugin, } from './plugins/chat';
 import { ChatHeaderPlugin } from './plugins/chat-header';
 import { A2uiSurfacePlugin } from './plugins/a2ui-surface';
 import { PapSignInPlugin } from './plugins/pap-sign-in';
+import { ShieldDisplaysPlugin } from './plugins/shield-displays';
 import { ChatViewPlugin } from './plugins/chat-view';
 import { DocumentViewPlugin } from './plugins/document-view';
 import { InputPromptPlugin } from './plugins/input-prompt';
@@ -109,6 +110,9 @@ export function loopPlugins(options = {}) {
         // *Sign in at a company*, where the gateway's `pap_sign_in` answers: its
         // own renderer and binding, beside the surfaces rather than inside them.
         PapSignInPlugin,
+        // A coding agent's diff and terminal, where its tool results carry them
+        // (SHIELD §4.3): two renderers, no binding — the display says what it is.
+        ShieldDisplaysPlugin,
         // One footer icon per view, in the composer where the writing hand
         // already is. Each editor's icon withdraws while its editor is not
         // contributed, so mounting these unconditionally costs an absent editor

package/lib/portable/displays.d.ts

@@ -18,6 +18,11 @@
  *   where the conversation stands — participation.
  * - **A handoff** (`pap_handoff`'s answer): handed to the company's people,
  *   or why not.
+ * - **A diff** (`…shield.diff+json`, SHIELD §4.3): what a coding agent
+ *   changed in one file — its path, what it held, what it holds now, the
+ *   file's language — drawn as a unified diff (`unifiedDiffLines`).
+ * - **A terminal** (`…shield.terminal+json`): what it ran — the command, the
+ *   output kept after release, the exit code.
  *
  * Anything else — an unknown type, a known one whose data does not read — is
  * `unknown`: its type, version and model-safe text, nothing drawn from its
@@ -30,6 +35,8 @@ export declare const PAP_SIGN_IN_TYPE = "application/vnd.datalayer.pap.sign-in+j
 export declare const PAP_CONFIRM_TYPE = "application/vnd.datalayer.pap.confirm+json";
 export declare const PAP_OUTCOME_TYPE = "application/vnd.datalayer.pap.outcome+json";
 export declare const PAP_REPLIES_TYPE = "application/vnd.datalayer.pap.replies+json";
+export declare const SHIELD_DIFF_TYPE = "application/vnd.datalayer.shield.diff+json";
+export declare const SHIELD_TERMINAL_TYPE = "application/vnd.datalayer.shield.terminal+json";
 /** Where a tool result carries its display for the page. */
 export declare const DISPLAY_META_KEY = "reactor.ui/display";
 /** What confirming an operation does, as an application's Rules class it. */
@@ -86,6 +93,27 @@ export type ProtocolDisplay = ({
     handed: boolean;
     responder: 'agent' | 'human' | null;
     note: string;
+} | {
+    kind: 'diff';
+    id: string;
+    /** The file, as the agent named it, relative to its workspace. */
+    path: string;
+    /** What it held; `null` for a file that did not exist. */
+    oldText: string | null;
+    newText: string;
+    /** A highlighter's language name, from the file's suffix (`text` when none). */
+    language: string;
+} | {
+    kind: 'terminal';
+    id: string;
+    terminalId: string;
+    /** What it ran, when known. */
+    command: string;
+    /** The output, kept after the terminal was released. */
+    output: string;
+    /** `null` while it runs. */
+    exitCode: number | null;
+    released: boolean;
 } | {
     kind: 'unknown';
     id: string;
@@ -107,3 +135,22 @@ export declare function displayOfToolResult(toolName: string, result: unknown, i
 export declare function displayLine(display: ProtocolDisplay): string;
 /** Who wrote a reply, said apart from the person's words and the agent's summaries (PAP-7.8-01). */
 export declare const replyAuthor: (company: string, sender: "agent" | "human") => string;
+/** The language a file's suffix says, for highlighting; `text` when none. */
+export declare function languageOf(path: string): string;
+/** One line of a unified diff: kept, added or removed. */
+export type DiffLine = {
+    kind: 'context' | 'add' | 'remove';
+    text: string;
+};
+/** Over this many lines on a side, the diff is shown whole (all removed, all added), not computed. */
+export declare const DIFF_LINES_LIMIT = 2000;
+/**
+ * The lines of a unified diff between what a file held and what it holds,
+ * by a longest common subsequence of lines; a file over `DIFF_LINES_LIMIT`
+ * lines on a side is shown removed and added whole.
+ */
+export declare function unifiedDiffLines(oldText: string | null, newText: string): DiffLine[];
+/** The unified diff as text (`--- a/path`, `+++ b/path`, one sign per line), as a terminal shows it. */
+export declare function unifiedDiffText(display: Extract<ProtocolDisplay, {
+    kind: 'diff';
+}>): string;

package/lib/portable/displays.js

@@ -22,6 +22,11 @@
  *   where the conversation stands — participation.
  * - **A handoff** (`pap_handoff`'s answer): handed to the company's people,
  *   or why not.
+ * - **A diff** (`…shield.diff+json`, SHIELD §4.3): what a coding agent
+ *   changed in one file — its path, what it held, what it holds now, the
+ *   file's language — drawn as a unified diff (`unifiedDiffLines`).
+ * - **A terminal** (`…shield.terminal+json`): what it ran — the command, the
+ *   output kept after release, the exit code.
  *
  * Anything else — an unknown type, a known one whose data does not read — is
  * `unknown`: its type, version and model-safe text, nothing drawn from its
@@ -34,6 +39,8 @@ export const PAP_SIGN_IN_TYPE = 'application/vnd.datalayer.pap.sign-in+json';
 export const PAP_CONFIRM_TYPE = 'application/vnd.datalayer.pap.confirm+json';
 export const PAP_OUTCOME_TYPE = 'application/vnd.datalayer.pap.outcome+json';
 export const PAP_REPLIES_TYPE = 'application/vnd.datalayer.pap.replies+json';
+export const SHIELD_DIFF_TYPE = 'application/vnd.datalayer.shield.diff+json';
+export const SHIELD_TERMINAL_TYPE = 'application/vnd.datalayer.shield.terminal+json';
 /** Where a tool result carries its display for the page. */
 export const DISPLAY_META_KEY = 'reactor.ui/display';
 const record = (value) => value && typeof value === 'object' && !Array.isArray(value)
@@ -185,6 +192,46 @@ export function protocolDisplayOf(wire) {
                 responder: who(data.responder),
             };
         }
+        case SHIELD_DIFF_TYPE: {
+            const path = words(data.path);
+            if (!path ||
+                typeof data.new_text !== 'string' ||
+                !(data.old_text === null ||
+                    data.old_text === undefined ||
+                    typeof data.old_text === 'string')) {
+                return unknown;
+            }
+            return {
+                kind: 'diff',
+                id,
+                path,
+                oldText: typeof data.old_text === 'string' ? data.old_text : null,
+                newText: data.new_text,
+                language: words(data.language) || languageOf(path),
+            };
+        }
+        case SHIELD_TERMINAL_TYPE: {
+            const terminalId = words(data.terminal_id);
+            if (!terminalId)
+                return unknown;
+            const exitCode = typeof data.exit_code === 'number' && Number.isInteger(data.exit_code)
+                ? data.exit_code
+                : null;
+            if (data.exit_code !== null &&
+                data.exit_code !== undefined &&
+                exitCode === null) {
+                return unknown;
+            }
+            return {
+                kind: 'terminal',
+                id,
+                terminalId,
+                command: text(data.command),
+                output: text(data.output),
+                exitCode,
+                released: data.released === true,
+            };
+        }
         default:
             return unknown;
     }
@@ -245,6 +292,21 @@ export function displayLine(display) {
             return display.handed
                 ? `Handed to ${display.responder === 'human' ? 'one of the company’s people' : 'the company'}`
                 : display.note || 'Nothing was handed over.';
+        case 'diff': {
+            const added = countLines(display.newText);
+            if (display.oldText === null) {
+                return `Wrote ${display.path} (${added} lines)`;
+            }
+            return `Changed ${display.path} (+${added} −${countLines(display.oldText)} lines)`;
+        }
+        case 'terminal': {
+            const what = display.command
+                ? `Ran \`${display.command}\``
+                : `Terminal ${display.terminalId}`;
+            return display.exitCode === null
+                ? `${what}: running`
+                : `${what}: exit ${display.exitCode}`;
+        }
         case 'unknown':
             return display.text || `A display this app cannot draw (${display.type})`;
     }
@@ -259,3 +321,111 @@ const OUTCOME_LEADS = {
 export const replyAuthor = (company, sender) => sender === 'human'
     ? `${company}, one of its people`
     : `${company}, its agent`;
+// -- a diff and a terminal (SHIELD §4.3, SH-16) ------------------------------------
+const countLines = (value) => value === '' ? 0 : value.split('\n').length - (value.endsWith('\n') ? 1 : 0);
+/** A file's language from its suffix, the same table the runtime uses. */
+const LANGUAGES = {
+    py: 'python',
+    pyi: 'python',
+    ts: 'typescript',
+    tsx: 'tsx',
+    js: 'javascript',
+    jsx: 'jsx',
+    mjs: 'javascript',
+    json: 'json',
+    md: 'markdown',
+    mdx: 'markdown',
+    yaml: 'yaml',
+    yml: 'yaml',
+    toml: 'toml',
+    sh: 'bash',
+    bash: 'bash',
+    css: 'css',
+    scss: 'scss',
+    html: 'html',
+    xml: 'xml',
+    sql: 'sql',
+    rs: 'rust',
+    go: 'go',
+    java: 'java',
+    c: 'c',
+    h: 'c',
+    cpp: 'cpp',
+    rb: 'ruby',
+    ipynb: 'json',
+    txt: 'text',
+};
+/** The language a file's suffix says, for highlighting; `text` when none. */
+export function languageOf(path) {
+    const name = path.split('/').pop() ?? '';
+    if (name === 'Dockerfile' || name === 'Makefile')
+        return name.toLowerCase();
+    const dot = name.lastIndexOf('.');
+    return dot > 0
+        ? (LANGUAGES[name.slice(dot + 1).toLowerCase()] ?? 'text')
+        : 'text';
+}
+/** Over this many lines on a side, the diff is shown whole (all removed, all added), not computed. */
+export const DIFF_LINES_LIMIT = 2000;
+const lines = (value) => value === '' ? [] : value.replace(/\n$/, '').split('\n');
+/**
+ * The lines of a unified diff between what a file held and what it holds,
+ * by a longest common subsequence of lines; a file over `DIFF_LINES_LIMIT`
+ * lines on a side is shown removed and added whole.
+ */
+export function unifiedDiffLines(oldText, newText) {
+    const before = oldText === null ? [] : lines(oldText);
+    const after = lines(newText);
+    if (before.length > DIFF_LINES_LIMIT || after.length > DIFF_LINES_LIMIT) {
+        return [
+            ...before.map(text => ({ kind: 'remove', text })),
+            ...after.map(text => ({ kind: 'add', text })),
+        ];
+    }
+    // The LCS table, one row per line of `before`.
+    const table = [];
+    for (let i = 0; i <= before.length; i++) {
+        table.push(new Uint32Array(after.length + 1));
+    }
+    for (let i = before.length - 1; i >= 0; i--) {
+        for (let j = after.length - 1; j >= 0; j--) {
+            table[i][j] =
+                before[i] === after[j]
+                    ? table[i + 1][j + 1] + 1
+                    : Math.max(table[i + 1][j], table[i][j + 1]);
+        }
+    }
+    const out = [];
+    let i = 0;
+    let j = 0;
+    while (i < before.length && j < after.length) {
+        if (before[i] === after[j]) {
+            out.push({ kind: 'context', text: before[i] });
+            i++;
+            j++;
+        }
+        else if (table[i + 1][j] >= table[i][j + 1]) {
+            out.push({ kind: 'remove', text: before[i] });
+            i++;
+        }
+        else {
+            out.push({ kind: 'add', text: after[j] });
+            j++;
+        }
+    }
+    while (i < before.length)
+        out.push({ kind: 'remove', text: before[i++] });
+    while (j < after.length)
+        out.push({ kind: 'add', text: after[j++] });
+    return out;
+}
+/** The unified diff as text (`--- a/path`, `+++ b/path`, one sign per line), as a terminal shows it. */
+export function unifiedDiffText(display) {
+    const from = display.oldText === null ? '/dev/null' : `a/${display.path}`;
+    const signs = { context: ' ', add: '+', remove: '-' };
+    return [
+        `--- ${from}`,
+        `+++ b/${display.path}`,
+        ...unifiedDiffLines(display.oldText, display.newText).map(line => `${signs[line.kind]}${line.text}`),
+    ].join('\n');
+}

package/lib/portable/fixtures.d.ts

@@ -8,4 +8,13 @@
  */
 import { type ConversationState } from './conversation';
 /** A fresh copy of the fixture conversation. */
+/**
+ * A coding agent's diff and terminal, as the runtime sends them beside a tool
+ * result (`_meta["reactor.ui/display"]`, SHIELD §4.3, SH-16): what the phone
+ * draws for MOBILE M-037, read by `protocolDisplayOf`.
+ */
+export declare function shieldDisplayFixtures(): {
+    diff: Record<string, unknown>;
+    terminal: Record<string, unknown>;
+};
 export declare function conversationFixture(): ConversationState;

package/lib/portable/fixtures.js

@@ -13,6 +13,42 @@
 import { emptyConversation } from './conversation';
 import { RUN_END_WORDS } from './records';
 /** A fresh copy of the fixture conversation. */
+/**
+ * A coding agent's diff and terminal, as the runtime sends them beside a tool
+ * result (`_meta["reactor.ui/display"]`, SHIELD §4.3, SH-16): what the phone
+ * draws for MOBILE M-037, read by `protocolDisplayOf`.
+ */
+export function shieldDisplayFixtures() {
+    return {
+        diff: {
+            type: 'application/vnd.datalayer.shield.diff+json',
+            version: 1,
+            id: 'c1-diff',
+            text: 'Changed hello.py (+2 −1 lines)',
+            data: {
+                path: 'hello.py',
+                old_text: 'print("hi")\n',
+                new_text: 'def hello():\n    print("hi, shield")\n',
+                language: 'python',
+            },
+            actions: [],
+        },
+        terminal: {
+            type: 'application/vnd.datalayer.shield.terminal+json',
+            version: 1,
+            id: 'c3-terminal',
+            text: 'Ran `pytest -q`: exit 0',
+            data: {
+                terminal_id: 'term_1',
+                command: 'pytest -q',
+                output: '3 passed in 0.12s\n',
+                exit_code: 0,
+                released: true,
+            },
+            actions: [],
+        },
+    };
+}
 export function conversationFixture() {
     return {
         ...emptyConversation(),

package/lib/portable/index.d.ts

@@ -17,7 +17,8 @@ export { conversationEventsOf, sanitizeAssistantContent, snapshotOfMessages, typ
 export { PRESENCE_LINES, presenceOfConversation, presenceState, presenceToolOf, type PresenceState, type PresenceTool, } from './presence';
 export { ANSWER_BELOW, ANSWER_COMPLETE, composerOf, droppedWords, ENDED_WORDS, messageLabel, OPENING_WORDS, presenceLine, showsQuestion, stepLine, TOOL_STATUS_WORDS, toolLabel, type ComposerProps, type ComposerState, type ConversationViewProps, type ErrorItem, type ErrorRowProps, type MessageItem, type MessageRowProps, type PresenceLineProps, type ProtocolDisplayProps, type QuestionCardProps, type StepItem, type StepRowProps, type ToolItem, type ToolRowProps, type TurnEndItem, type TurnEndRowProps, } from './views';
 export { conversationFixture } from './fixtures';
-export { DISPLAY_META_KEY, displayLine, displayOfToolResult, PAP_CONFIRM_TYPE, PAP_HANDOFF_TOOL, PAP_OUTCOME_TYPE, PAP_REPLIES_TYPE, PAP_SIGN_IN_TYPE, protocolDisplayOf, replyAuthor, type ActionClass, type ProtocolDisplay, } from './displays';
+export { DISPLAY_META_KEY, displayLine, displayOfToolResult, PAP_CONFIRM_TYPE, PAP_HANDOFF_TOOL, PAP_OUTCOME_TYPE, PAP_REPLIES_TYPE, PAP_SIGN_IN_TYPE, protocolDisplayOf, replyAuthor, type ActionClass, type ProtocolDisplay, DIFF_LINES_LIMIT, SHIELD_DIFF_TYPE, SHIELD_TERMINAL_TYPE, languageOf, unifiedDiffLines, unifiedDiffText, type DiffLine, } from './displays';
+export { shieldDisplayFixtures } from './fixtures';
 export { isPapSignInTool, PAP_SIGN_IN_WORDS, readPapSignIn, safeSignInUrl, type PapSignInWaiting, } from './signIn';
 export { DIRECT_MAX, DIRECT_WORDS, directAnswerOf, directAuthor, directClient, openDirect, withDirectAnswer, type DirectAnswer, type DirectClient, type DirectClientOptions, type DirectLine, type DirectOpen, type DirectReply, type DirectTarget, } from './direct';
 export { SIGN_IN_POLL_MS, SIGN_IN_STATUS_PATH, signInStandsOf, signInStatusClient, type SignInStands, } from './signInStatus';

package/lib/portable/index.js

@@ -29,7 +29,10 @@ export { PRESENCE_LINES, presenceOfConversation, presenceState, presenceToolOf,
 export { ANSWER_BELOW, ANSWER_COMPLETE, composerOf, droppedWords, ENDED_WORDS, messageLabel, OPENING_WORDS, presenceLine, showsQuestion, stepLine, TOOL_STATUS_WORDS, toolLabel, } from './views';
 export { conversationFixture } from './fixtures';
 // The protocol displays a run's tool results carry (MOBILE M-037).
-export { DISPLAY_META_KEY, displayLine, displayOfToolResult, PAP_CONFIRM_TYPE, PAP_HANDOFF_TOOL, PAP_OUTCOME_TYPE, PAP_REPLIES_TYPE, PAP_SIGN_IN_TYPE, protocolDisplayOf, replyAuthor, } from './displays';
+export { DISPLAY_META_KEY, displayLine, displayOfToolResult, PAP_CONFIRM_TYPE, PAP_HANDOFF_TOOL, PAP_OUTCOME_TYPE, PAP_REPLIES_TYPE, PAP_SIGN_IN_TYPE, protocolDisplayOf, replyAuthor, 
+// A coding agent's diff and terminal (SHIELD §4.3, SH-16).
+DIFF_LINES_LIMIT, SHIELD_DIFF_TYPE, SHIELD_TERMINAL_TYPE, languageOf, unifiedDiffLines, unifiedDiffText, } from './displays';
+export { shieldDisplayFixtures } from './fixtures';
 export { isPapSignInTool, PAP_SIGN_IN_WORDS, readPapSignIn, safeSignInUrl, } from './signIn';
 // A Direct Conversation the person types in themselves (PAP_DATALAYER P-08, MOBILE M-038).
 export { DIRECT_MAX, DIRECT_WORDS, directAnswerOf, directAuthor, directClient, openDirect, withDirectAnswer, } from './direct';

package/lib/portable/views.d.ts

@@ -61,7 +61,9 @@ export type QuestionCardProps = {
 };
 /**
  * A protocol display under its tool row (MOBILE M-037): what it shows is
- * `displayLine`'s and the display's own; what the person does goes out
+ * `displayLine`'s and the display's own — a coding agent's `diff` as a
+ * unified diff in the file's language (`unifiedDiffLines`), its `terminal`
+ * as the command and the output kept (SHIELD §4.3); what the person does goes out
  * through the host — a sign-in page opened outside the conversation, an
  * operation answered where approvals are, *I have signed in* said as their
  * next message. Nothing is answered from the card itself.

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@datalayer/agent-runtimes",
-    "version": "1.5.33",
+    "version": "1.5.34",
     "type": "module",
     "workspaces": [
         ".",