@kabmo-labs/kabmo 0.0.0-stage → 0.1.0

package/src/shared/lib/chat/tool/wait-facts.ts

@@ -0,0 +1,50 @@
+/**
+ * @license
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * The fact chips for a `wait` call.
+ *
+ * Split out of `summary.ts`, which is at the repo's per-file ceiling, and the
+ * same contract as its `proc` sibling: the facts describe the WAIT, not the
+ * transport. A wait's own facts are the clock and what it watched, and the
+ * clock is load-bearing — omp reports no duration on the result at all, so the
+ * value comes from the snapshot's job `durationMs` while the call blocks and
+ * from the span the fold measured once it settles. Without it a call that
+ * blocked for two minutes read exactly like one that returned instantly.
+ */
+
+import type { ToolCallData } from '@/shared/types/chat';
+import { waitCounts, waitHitLimit, waitJobSpanMs, waitViewOf } from '@/shared/lib/omp/session/wait';
+import { countPhrase, formatToolMs } from '@/shared/lib/chat/tool/labels';
+import type { ToolFact } from '@/shared/lib/chat/tool/summary';
+
+/** Facts for a `wait` result (and a `send`, which shares `CoordinationDetails`). */
+export function waitFacts(tool: ToolCallData): ToolFact[] {
+  const view = waitViewOf(tool);
+  if (!view) return [];
+  const facts: ToolFact[] = [];
+  const counts = waitCounts(view);
+  // The CALL's span, never a watched job's: a job routinely starts before the
+  // wait that watches it (measured: `bg_8` reported 126 s while the call that
+  // waited on it took 20 s). The job span is only a fallback for a call whose
+  // own clock is unknown.
+  const elapsed = tool.durationMs
+    ?? (tool.startedAt !== undefined ? Math.max(0, Date.now() - tool.startedAt) : waitJobSpanMs(view));
+  if (elapsed !== undefined) facts.push({ kind: 'time', label: formatToolMs(elapsed) });
+  if (counts.total > 0) {
+    facts.push({ kind: 'count', label: countPhrase(counts.total, 'job') });
+    if (counts.running > 0) facts.push({ kind: 'note', label: `${counts.running} running` });
+    if (counts.failed > 0) facts.push({ kind: 'warn', label: `${counts.failed} failed`, tone: 'error' });
+  }
+  if (view.interrupted) facts.push({ kind: 'warn', label: 'interrupted', tone: 'warn' });
+  // The cap firing is an OUTCOME, not an absence: omp answers the same
+  // `{op:'wait', jobs:[]}` for a service wake, and only the prose tells them
+  // apart. Without this chip a capped wait read as `no jobs`, which says the
+  // call found nothing rather than that it ran out of time.
+  else if (waitHitLimit(view, tool.output)) facts.push({ kind: 'warn', label: '30m limit reached', tone: 'warn' });
+  else if (view.waited) facts.push({ kind: 'note', label: 'message received' });
+  else if (counts.total === 0) facts.push({ kind: 'note', label: 'no jobs' });
+  return facts;
+}

package/src/shared/lib/chat/tool-output.test.ts

@@ -0,0 +1,206 @@
+/**
+ * @license
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * Tool output is rendered as markdown, with one override: an XML wrapper that
+ * opens the output is transport, not content, so it is peeled before parsing.
+ * What makes the parser hard is telling that wrapper apart from markup that IS
+ * the content — a tag in the middle of prose, a mismatched pair, a second
+ * element after the first, a tag inside a fenced or inline code sample — and
+ * from content markdown would reflow (a log, a JSON body) once the wrapper is
+ * gone.
+ */
+
+import { describe, expect, test } from 'bun:test';
+
+import { outputMarkdown, readToolOutput } from '@/shared/lib/chat/tool-output';
+
+describe('readToolOutput XML envelope', () => {
+  test('peels a wrapper that opens the output and keeps the trailing line', () => {
+    const output = readToolOutput(
+      '<system-reminder reason="rule_violation" rule="ts-no-inline-cast-access">\n' +
+        'MUST comply with the following instruction.\n' +
+        '</system-reminder>\n' +
+        'Successfully wrote 3604 bytes to src/a.ts',
+    );
+
+    expect(output.envelopes[0]?.tag).toBe('system-reminder');
+    expect(output.envelopes[0]?.attributes).toEqual({
+      reason: 'rule_violation',
+      rule: 'ts-no-inline-cast-access',
+    });
+    expect(output.content).toBe(
+      'MUST comply with the following instruction.\n\nSuccessfully wrote 3604 bytes to src/a.ts',
+    );
+  });
+
+  test('reads single-quoted and valueless attributes', () => {
+    expect(readToolOutput("<a rule='ts-x' flag>\nbody\n</a>").envelopes[0]?.attributes).toEqual({
+      rule: 'ts-x',
+      flag: '',
+    });
+  });
+
+  test('dedents the wrapper body so markdown reads it as prose, not a code block', () => {
+    const output = readToolOutput('<result>\n  # Judul\n  teks biasa\n</result>');
+
+    expect(output.content).toBe('# Judul\nteks biasa');
+    expect(output.format).toBe('markdown');
+    expect(outputMarkdown(output.content, output.format)).toBe('# Judul\nteks biasa');
+  });
+
+  test('handles a `>` inside an attribute value and nested elements', () => {
+    expect(readToolOutput('<a title="x > y">\n<b>1</b>\n</a>').content).toBe('<b>1</b>');
+  });
+
+  test('leaves markup that does not open the output alone', () => {
+    const raw = 'Set <name> to the file, then run <cmd />';
+    const output = readToolOutput(raw);
+
+    expect(output.envelopes).toEqual([]);
+    expect(output.content).toBe(raw);
+  });
+
+  test('leaves mismatched and self-closing roots alone', () => {
+    expect(readToolOutput('<a>\n<b>x</a>').envelopes).toEqual([]);
+    expect(readToolOutput('<hr />').envelopes).toEqual([]);
+    expect(readToolOutput('<!-- note -->\nbody').envelopes).toEqual([]);
+  });
+
+  test('does not peel when a non-reminder sibling element follows', () => {
+    expect(readToolOutput('<a>1</a><b>2</b>').envelopes).toEqual([]);
+    expect(readToolOutput('<div><p>a</p></div><div>b</div>').envelopes).toEqual([]);
+  });
+});
+
+/**
+ * A reminder that documents a rule carries the rule's own TypeScript — and that
+ * sample contains markup (`Promise<LoadedConfig>`, `<div>` in a fenced block).
+ * Reading those as tags unbalanced the scan, so the wrapper was never
+ * recognized and the whole reminder leaked into the timeline as raw markup.
+ * Measured on this install: 99 of 352 reminder blocks carry such a sample.
+ */
+describe('readToolOutput envelope scan ignores code', () => {
+  test('a fenced block hides the markup inside it', () => {
+    const output = readToolOutput(
+      '<system-reminder rule="ts-no-return-type">\n' +
+        'Name the type at the module that owns the value.\n\n' +
+        '```typescript\n' +
+        'type Config = Awaited<ReturnType<typeof loadConfig>>;\n' +
+        'export function loadConfig(path: string): Promise<LoadedConfig> { ... }\n' +
+        '```\n' +
+        '</system-reminder>',
+    );
+
+    expect(output.envelopes[0]?.attributes.rule).toBe('ts-no-return-type');
+    expect(output.content).toContain('Promise<LoadedConfig>');
+  });
+
+  test('an inline code span hides the markup inside it', () => {
+    const output = readToolOutput(
+      '<system-reminder rule="ts-no-return-type">\n' +
+        'Do not publish contracts through `ReturnType<typeof fn>`.\n' +
+        '</system-reminder>',
+    );
+
+    expect(output.envelopes[0]?.tag).toBe('system-reminder');
+    expect(output.content).toBe('Do not publish contracts through `ReturnType<typeof fn>`.');
+  });
+
+  test('a lone backtick pair does not swallow the wrapper end tag', () => {
+    const output = readToolOutput(
+      '<system-reminder>\nwrite `` to xd://propose\n</system-reminder>',
+    );
+
+    expect(output.envelopes[0]?.tag).toBe('system-reminder');
+    expect(output.content).toBe('write `` to xd://propose');
+  });
+});
+
+/**
+ * omp emits ONE REMINDER PER MATCHED RULE, so a single tool result routinely
+ * opens with two of them. Refusing the run as "a sibling element" is what left
+ * 86 of this install's 353 reminder blocks rendered as raw markup.
+ */
+describe('readToolOutput reminder runs', () => {
+  test('peels every reminder of a run, keeping each one\u2019s attributes', () => {
+    const output = readToolOutput(
+      '<system-reminder rule="ts-no-tiny-functions">\nInline it.\n</system-reminder>\n\n' +
+        '<system-reminder rule="ts-set-map">\nUse a Record.\n</system-reminder>',
+    );
+
+    expect(output.envelopes.map((envelope) => envelope.attributes.rule)).toEqual([
+      'ts-no-tiny-functions',
+      'ts-set-map',
+    ]);
+    expect(output.content).toBe('Inline it.\n\nUse a Record.');
+  });
+
+  test('a run keeps free text that follows the last wrapper', () => {
+    const output = readToolOutput(
+      '<system-reminder>\nfirst\n</system-reminder>\n\n' +
+        '<system-reminder>\nsecond\n</system-reminder>\n\n' +
+        'Successfully wrote 3604 bytes to src/a.ts',
+    );
+
+    expect(output.envelopes).toHaveLength(2);
+    expect(output.content).toBe('first\n\nsecond\n\nSuccessfully wrote 3604 bytes to src/a.ts');
+  });
+});
+
+/**
+ * omp rewrites a command and reports it AFTER the output, so there is no
+ * leading wrapper to peel — `<system-warning>` on its own line at the end is
+ * the shape, and rendered as markdown it showed as escaped markup.
+ */
+describe('readToolOutput trailing notice', () => {
+  test('peels a notice appended after the output', () => {
+    const output = readToolOutput(
+      'start-command-template.md\ntelegram.md\nthemes.md\n\n' +
+        '<system-warning>Stripped redundant `| head -50` — bash output is already truncated.</system-warning>',
+    );
+
+    expect(output.envelopes.map((envelope) => envelope.tag)).toEqual(['system-warning']);
+    expect(output.content).toBe(
+      'start-command-template.md\ntelegram.md\nthemes.md\n\n' +
+        'Stripped redundant `| head -50` — bash output is already truncated.',
+    );
+  });
+
+  test('a notice quoted inside the output stays content', () => {
+    const quoted = "f.ts:1:  '<system-warning>x</system-warning>'";
+    const output = readToolOutput(quoted);
+
+    expect(output.envelopes).toEqual([]);
+    expect(output.content).toBe(quoted);
+  });
+
+  test('a trailing notice must close the output', () => {
+    // Output first, notice on its own line, then more output: the pair does not
+    // end the text, so it is content rather than a notice omp appended.
+    const raw = 'line one\n\n<system-warning>x</system-warning>\nmore output';
+    const output = readToolOutput(raw);
+
+    expect(output.envelopes).toEqual([]);
+    expect(output.content).toBe(raw);
+  });
+});
+
+describe('outputMarkdown', () => {
+  test('fences JSON so the parser cannot reflow it', () => {
+    const output = readToolOutput('{\n  "a": 1\n}');
+
+    expect(output.format).toBe('json');
+    expect(outputMarkdown(output.content, output.format)).toBe('```json\n{\n  "a": 1\n}\n```');
+  });
+
+  test('fences a plain log without a language', () => {
+    expect(outputMarkdown('error: boom\n  at foo', 'text')).toBe('```\nerror: boom\n  at foo\n```');
+  });
+
+  test('outgrows a fence already present in the content', () => {
+    expect(outputMarkdown('a ``` b', 'json')).toBe('````json\na ``` b\n````');
+  });
+});

package/src/shared/lib/chat/tool-output.ts

@@ -0,0 +1,68 @@
+/**
+ * @license
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * The one rule every tool-output surface follows: **output is rendered as
+ * markdown**.
+ *
+ * Two things happen before the parser sees it:
+ *
+ * 1. XML envelopes wrapping the output are peeled
+ *    (`<system-reminder …>…</system-reminder>`, `<result>…</result>`). Those
+ *    tags are transport — left in place, markdown escapes them and the user
+ *    reads markup instead of the message it carries. omp emits one reminder
+ *    PER MATCHED RULE, so a single tool result routinely opens with two.
+ * 2. Content markdown would reflow gets fenced. A log, a JSON body, an HTML
+ *    dump have no blank lines and no markers: parsed as prose they collapse
+ *    into a single paragraph and their `#`/`-` lines turn into headings and
+ *    bullets. A fence is still markdown, and it is the only shape that keeps
+ *    such a blob verbatim.
+ */
+
+import { detectOutputFormat, type OutputFormat } from '@/shared/lib/chat/detect-format';
+import { takeTrailingNotice, unwrapXmlEnvelopes, type XmlEnvelope } from '@/shared/lib/chat/xml-envelope';
+
+export interface ToolOutputText {
+  /** What the user reads: the XML envelopes peeled off, if there were any. */
+  content: string;
+  /** Format of `content`, deciding how `outputMarkdown` renders it. */
+  format: OutputFormat;
+  /** Wrappers that were peeled — rendered as the output's headers. */
+  envelopes: XmlEnvelope[];
+}
+
+/** Read raw tool output into the text the timeline renders. */
+export function readToolOutput(text: string): ToolOutputText {
+  const leading = unwrapXmlEnvelopes(text);
+  // A notice omp appended AFTER the output (a rewritten command it reports
+  // after the fact) has no leading wrapper, so it is peeled from the tail.
+  const trailing = leading.length === 0 ? takeTrailingNotice(text) : undefined;
+  const envelopes = trailing ? [trailing.envelope] : leading;
+  const content = trailing
+    ? [trailing.before, trailing.envelope.inner].filter(Boolean).join('\n\n')
+    : envelopes.length > 0
+      ? [
+          ...envelopes.map((envelope) => envelope.inner),
+          ...envelopes.flatMap((envelope) => (envelope.rest ? [envelope.rest] : [])),
+        ]
+          .filter(Boolean)
+          .join('\n\n')
+      : text;
+  return {
+    content,
+    format: detectOutputFormat(content),
+    envelopes,
+  };
+}
+
+/** Markdown for output content — verbatim formats are fenced so the parser
+ *  cannot reflow them; markdown itself passes through untouched. */
+export function outputMarkdown(content: string, format: OutputFormat): string {
+  if (!content || format === 'markdown') return content;
+  let longest = 0;
+  for (const run of content.match(/`+/g) ?? []) longest = Math.max(longest, run.length);
+  const fence = '`'.repeat(Math.max(3, longest + 1));
+  return `${fence}${format === 'text' ? '' : format}\n${content}\n${fence}`;
+}

package/src/shared/lib/chat/tool-status.ts

@@ -0,0 +1,20 @@
+import type { ToolCallData } from '@/shared/types';
+
+/**
+ * Checks if a tool call was skipped, aborted, or synthetic (not actually executed).
+ * Skipped tools should not auto-expand or trigger error-state highlights.
+ */
+export function isSkippedTool(tool: ToolCallData): boolean {
+  if (tool.synthetic === true || tool.status === 'skipped' || tool.status === 'aborted') {
+    return true;
+  }
+  const details = tool.details as Record<string, any> | undefined;
+  if (
+    details?.__synthetic === true ||
+    details?.source === 'assistant_stop_skipped' ||
+    details?.executed === false
+  ) {
+    return true;
+  }
+  return false;
+}

package/src/shared/lib/chat/xml-envelope.test.ts

@@ -0,0 +1,208 @@
+/**
+ * @license
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * These tests pin the envelope layer that sits on top of the XML scanner: which
+ * wrappers count as runtime notices, how a run of notices is peeled, and how a
+ * notice appended AFTER output is told apart from a notice merely quoted by it.
+ * The risky behavior is the boundary between transport and content — a second
+ * element after a non-notice wrapper is content (`[]`), free text after the last
+ * wrapper rides along as `rest`, and a trailing notice only counts when it sits
+ * on its own line at the very end, so `rg` output that prints a reminder as
+ * source text stays untouched.
+ */
+
+import { describe, expect, test } from 'bun:test';
+
+import {
+  isReminderTag,
+  stripNoticeTags,
+  takeTrailingNotice,
+  unwrapXmlEnvelope,
+  unwrapXmlEnvelopes,
+} from '@/shared/lib/chat/xml-envelope';
+
+describe('isReminderTag', () => {
+  test('accepts the runtime-notice wrappers', () => {
+    for (const tag of ['system-reminder', 'reminder', 'system-interrupt', 'system-warning', 'system-directive']) {
+      expect(isReminderTag(tag)).toBe(true);
+    }
+  });
+
+  test('rejects a result wrapper and a task-card wrapper', () => {
+    expect(isReminderTag('result')).toBe(false);
+    expect(isReminderTag('system-notice')).toBe(false);
+    expect(isReminderTag('')).toBe(false);
+  });
+});
+
+describe('stripNoticeTags', () => {
+  test('drops a notice wrapper and keeps its text', () => {
+    expect(stripNoticeTags('<system-reminder reason="x">hi</system-reminder>')).toBe('hi');
+  });
+
+  test('also drops the task-card wrappers', () => {
+    expect(stripNoticeTags('<task-result>y</task-result>')).toBe('y');
+    expect(stripNoticeTags('<system-notice>n</system-notice>')).toBe('n');
+  });
+
+  test('leaves a non-listed wrapper alone', () => {
+    expect(stripNoticeTags('<result>z</result>')).toBe('<result>z</result>');
+  });
+
+  test('matches case-insensitively but respects a word boundary', () => {
+    expect(stripNoticeTags('<SYSTEM-WARNING>w</SYSTEM-WARNING>')).toBe('w');
+    expect(stripNoticeTags('<system-reminderx>no</system-reminderx>')).toBe('<system-reminderx>no</system-reminderx>');
+  });
+});
+
+describe('unwrapXmlEnvelopes', () => {
+  test('returns nothing for empty or whitespace-only text', () => {
+    expect(unwrapXmlEnvelopes('')).toEqual([]);
+    expect(unwrapXmlEnvelopes('  \n ')).toEqual([]);
+  });
+
+  test('peels a leading wrapper of any name', () => {
+    expect(unwrapXmlEnvelopes('<result a="1" b="2">hi</result>')).toEqual([
+      { tag: 'result', attributes: { a: '1', b: '2' }, inner: 'hi' },
+    ]);
+    expect(unwrapXmlEnvelopes('<div>a</div>')[0]?.tag).toBe('div');
+  });
+
+  test('free text after the closing tag rides along as `rest`', () => {
+    expect(unwrapXmlEnvelopes('<result>hi</result> tail')).toEqual([
+      { tag: 'result', attributes: {}, inner: 'hi', rest: 'tail' },
+    ]);
+  });
+
+  test('a second element after a non-notice wrapper means there is no wrapper', () => {
+    expect(unwrapXmlEnvelopes('<result>hi</result><div>x</div>')).toEqual([]);
+  });
+
+  test('text before the first tag means the tag is content', () => {
+    expect(unwrapXmlEnvelopes('a <system-reminder>x</system-reminder>')).toEqual([]);
+  });
+
+  test('an unbalanced wrapper is not peeled', () => {
+    expect(unwrapXmlEnvelopes('<result>hi')).toEqual([]);
+  });
+
+  test('leading whitespace is allowed', () => {
+    expect(unwrapXmlEnvelopes('  <result>hi</result>')[0]?.inner).toBe('hi');
+  });
+
+  test('removes the common indent from the inner text', () => {
+    expect(unwrapXmlEnvelopes('<result>\n  line1\n  line2\n</result>')[0]?.inner).toBe('line1\nline2');
+  });
+
+  test('follows a run of notice wrappers', () => {
+    expect(unwrapXmlEnvelopes('<system-reminder>a</system-reminder>\n\n<system-reminder>b</system-reminder>')).toEqual([
+      { tag: 'system-reminder', attributes: {}, inner: 'a' },
+      { tag: 'system-reminder', attributes: {}, inner: 'b' },
+    ]);
+  });
+
+  test('the run stops at a non-notice sibling, which becomes `rest`', () => {
+    expect(unwrapXmlEnvelopes('<system-reminder>a</system-reminder><system-notice>b</system-notice>')).toEqual([
+      { tag: 'system-reminder', attributes: {}, inner: 'a', rest: '<system-notice>b</system-notice>' },
+    ]);
+    expect(
+      unwrapXmlEnvelopes('<system-reminder>a</system-reminder><system-reminder>b</system-reminder><div>x</div>'),
+    ).toEqual([
+      { tag: 'system-reminder', attributes: {}, inner: 'a' },
+      { tag: 'system-reminder', attributes: {}, inner: 'b', rest: '<div>x</div>' },
+    ]);
+  });
+
+  test('free text after the last notice rides on that notice', () => {
+    expect(
+      unwrapXmlEnvelopes('<system-reminder>a</system-reminder>\n\n<system-reminder>b</system-reminder>\ntail'),
+    ).toEqual([
+      { tag: 'system-reminder', attributes: {}, inner: 'a' },
+      { tag: 'system-reminder', attributes: {}, inner: 'b', rest: 'tail' },
+    ]);
+  });
+
+  test('re-wrapping the parsed fields reproduces the source', () => {
+    const source = '<result a="1">hi</result>';
+    const [envelope] = unwrapXmlEnvelopes(source);
+    expect(envelope).toBeDefined();
+    if (!envelope) return;
+    const attrs = Object.entries(envelope.attributes)
+      .map(([k, v]) => ` ${k}="${v}"`)
+      .join('');
+    expect(`<${envelope.tag}${attrs}>${envelope.inner}</${envelope.tag}>`).toBe(source);
+  });
+});
+
+describe('unwrapXmlEnvelope', () => {
+  test('returns only the first wrapper', () => {
+    expect(unwrapXmlEnvelope('<system-reminder>only</system-reminder>')).toEqual({
+      tag: 'system-reminder',
+      attributes: {},
+      inner: 'only',
+    });
+  });
+
+  test('is undefined when there is no wrapper', () => {
+    expect(unwrapXmlEnvelope('plain text')).toBeUndefined();
+  });
+});
+
+describe('takeTrailingNotice', () => {
+  test('peels a notice on its own line at the end of the output', () => {
+    expect(takeTrailingNotice('out\n<system-warning>w</system-warning>')).toEqual({
+      before: 'out',
+      envelope: { tag: 'system-warning', attributes: {}, inner: 'w' },
+    });
+  });
+
+  test('a final newline after the notice is still trailing', () => {
+    expect(takeTrailingNotice('out\n<system-warning>w</system-warning>\n')?.before).toBe('out');
+  });
+
+  test('a notice with no content before it is not trailing', () => {
+    expect(takeTrailingNotice('<system-warning>w</system-warning>')).toBeUndefined();
+  });
+
+  test('text after the closing tag disqualifies it', () => {
+    expect(takeTrailingNotice('out\n<system-warning>w</system-warning>tail')).toBeUndefined();
+  });
+
+  test('a notice that does not start its own line is content', () => {
+    expect(takeTrailingNotice('out <system-warning>w</system-warning>')).toBeUndefined();
+  });
+
+  test('a notice quoted in source code is not trailing', () => {
+    expect(takeTrailingNotice('const x = "<system-warning>w</system-warning>"')).toBeUndefined();
+  });
+
+  test('a tag the notice regex does not cover is ignored', () => {
+    expect(takeTrailingNotice('out\n<result>x</result>')).toBeUndefined();
+    expect(takeTrailingNotice('out\n<system-notice>x</system-notice>')).toBeUndefined();
+  });
+
+  test('an unbalanced notice is not peeled', () => {
+    expect(takeTrailingNotice('out\n<system-warning>unbalanced')).toBeUndefined();
+  });
+
+  test('the last notice wins and earlier text stays in `before`', () => {
+    expect(takeTrailingNotice('a\n<system-reminder>x</system-reminder>\n<system-warning>y</system-warning>')).toEqual({
+      before: 'a\n<system-reminder>x</system-reminder>',
+      envelope: { tag: 'system-warning', attributes: {}, inner: 'y' },
+    });
+  });
+
+  test('keeps the notice attributes and reports multi-line preceding text', () => {
+    expect(takeTrailingNotice('line1\nline2\n<system-interrupt>stop</system-interrupt>')).toEqual({
+      before: 'line1\nline2',
+      envelope: { tag: 'system-interrupt', attributes: {}, inner: 'stop' },
+    });
+    expect(takeTrailingNotice('out\n<system-reminder a="1">x</system-reminder>')).toEqual({
+      before: 'out',
+      envelope: { tag: 'system-reminder', attributes: { a: '1' }, inner: 'x' },
+    });
+  });
+});