@robota-sdk/agent-ui-terminal 3.0.0-beta.81

package/src/__tests__/effort-reaches-the-session.test.ts

@@ -0,0 +1,41 @@
+import { describe, expect, it } from 'vitest';
+
+import { buildTuiSessionOptions } from '../tui-session-options.js';
+
+import type { ITuiInteractionChannelOptions } from '../TuiInteractionChannel.js';
+
+/**
+ * ARCH-013 — a preset's `effort` is resolved at startup and then dropped.
+ *
+ * `TPresetEffort` is defined as `NonNullable<ICreateSessionOptions['effort']>` precisely so a preset
+ * can thread onto that seam, and three of the four built-in presets set it —
+ * `neutral-executor` asks for `'medium'`. At startup none of it arrives: no hop between the resolved
+ * preset and `createSession` carried the field, so the core applied its own `'high'` default.
+ *
+ * The same preset selected mid-session with `/preset` DOES apply it
+ * (`command-api/preset/preset-application.ts:91` → `applyModelOptions`), so one session could hold
+ * two different answers for the same preset depending on when it was chosen. That is the observable
+ * this pins, at the projection hop the TUI actually uses.
+ */
+function channelOptions(
+  overrides: Partial<ITuiInteractionChannelOptions> = {},
+): ITuiInteractionChannelOptions {
+  return { cwd: '/tmp', ...overrides } as ITuiInteractionChannelOptions;
+}
+
+describe('the TUI projection carries effort (ARCH-013)', () => {
+  it('forwards a resolved effort onto the session options', () => {
+    // Against the defect `effort` is not a key of the target type at all, so it is simply absent.
+    // Asserted over the entries rather than through a cast: the declared return type is the
+    // standard|injected union and only the standard arm can carry a construction-time option, but a
+    // double cast to reach the key would be the same "trust me" this whole item is about.
+    const built = buildTuiSessionOptions(channelOptions({ effort: 'medium' }));
+    expect(Object.entries(built)).toContainEqual(['effort', 'medium']);
+  });
+
+  it('omits the key entirely when no effort was resolved', () => {
+    // Not `undefined` — absent. The framework→provider seam owns the default, and a present-but-
+    // undefined key would claim a decision nobody made.
+    expect('effort' in buildTuiSessionOptions(channelOptions())).toBe(false);
+  });
+});

package/src/__tests__/execution-workspace-switcher.test.tsx

@@ -0,0 +1,147 @@
+import React from 'react';
+import { describe, expect, it, vi } from 'vitest';
+import { render } from 'ink-testing-library';
+import type {
+  IExecutionWorkspaceEntry,
+  IExecutionWorkspaceSnapshot,
+} from '@robota-sdk/agent-interface-execution';
+import ExecutionWorkspaceSwitcher from '../ExecutionWorkspaceSwitcher.js';
+import { formatKeyHints, SELECTION_INDICATOR } from '../key-hint-footer.js';
+import ExecutionWorkspaceDetailPane from '../ExecutionWorkspaceDetailPane.js';
+
+function makeEntry(overrides: Partial<IExecutionWorkspaceEntry>): IExecutionWorkspaceEntry {
+  return {
+    id: 'main:session_1',
+    sourceId: 'session_1',
+    kind: 'main_thread',
+    origin: { kind: 'user_prompt', sessionId: 'session_1' },
+    status: 'idle',
+    state: 'completed',
+    title: 'Main thread',
+    subtitle: '2 history entries',
+    unread: false,
+    attention: 'none',
+    visibility: 'default',
+    updatedAt: '2026-05-09T00:00:00.000Z',
+    controls: ['select'],
+    ...overrides,
+  };
+}
+
+function makeSnapshot(): IExecutionWorkspaceSnapshot {
+  return {
+    sessionId: 'session_1',
+    selectedEntryId: 'main:session_1',
+    updatedAt: '2026-05-09T00:00:00.000Z',
+    entries: [
+      makeEntry({ id: 'main:session_1', kind: 'main_thread', title: 'Main thread' }),
+      makeEntry({
+        id: 'task:agent_1',
+        sourceId: 'agent_1',
+        kind: 'background_task',
+        taskKind: 'agent',
+        status: 'running',
+        state: 'working',
+        title: 'Explore',
+        subtitle: 'general-purpose',
+        preview: 'Inspect task layer',
+        controls: ['select', 'cancel'],
+      }),
+    ],
+  };
+}
+
+describe('ExecutionWorkspaceSwitcher', () => {
+  it('renders main and background entries with selected radio markers', () => {
+    const { lastFrame } = render(
+      <ExecutionWorkspaceSwitcher
+        snapshot={makeSnapshot()}
+        selectedEntryId="task:agent_1"
+        onSelect={vi.fn()}
+        onClose={vi.fn()}
+      />,
+    );
+
+    const frame = lastFrame()!;
+    expect(frame).toContain('Execution workspace');
+    // SCREEN-1992: the state word sits beside the radio.
+    expect(frame).toContain('○ completed Main thread');
+    expect(frame).toContain('● working Explore agent');
+    expect(frame).toContain('Inspect task layer');
+  });
+
+  it('commits the highlighted entry on enter without invoking task controls', () => {
+    const onSelect = vi.fn();
+    const { stdin } = render(
+      <ExecutionWorkspaceSwitcher
+        snapshot={makeSnapshot()}
+        selectedEntryId="main:session_1"
+        onSelect={onSelect}
+        onClose={vi.fn()}
+      />,
+    );
+
+    stdin.write('\u001B[B');
+    stdin.write('\r');
+
+    expect(onSelect).toHaveBeenCalledWith('task:agent_1');
+  });
+
+  it('renders selected entry detail records from the SDK detail page', () => {
+    const entry = makeEntry({
+      id: 'task:agent_1',
+      sourceId: 'agent_1',
+      kind: 'background_task',
+      taskKind: 'agent',
+      status: 'completed',
+      title: 'Explore',
+      preview: 'Done',
+    });
+    const { lastFrame } = render(
+      <ExecutionWorkspaceDetailPane
+        entry={entry}
+        page={{
+          entryId: 'task:agent_1',
+          records: [{ id: 'r1', kind: 'result', text: 'Final background result' }],
+        }}
+      />,
+    );
+
+    const frame = lastFrame()!;
+    expect(frame).toContain('Viewing Explore agent');
+    expect(frame).toContain('Final background result');
+  });
+});
+
+// SCREEN-005: switcher footer + focused-row cursor go through the key-hint/indicator SSOT.
+describe('ExecutionWorkspaceSwitcher affordance (SCREEN-005)', () => {
+  it('renders the footer in the shared key-hint grammar (navigate → primary → dismiss)', () => {
+    const { lastFrame } = render(
+      <ExecutionWorkspaceSwitcher
+        snapshot={makeSnapshot()}
+        selectedEntryId="main:session_1"
+        onSelect={vi.fn()}
+        onClose={vi.fn()}
+      />,
+    );
+    expect(lastFrame()!).toContain(
+      formatKeyHints([
+        { keys: '↑↓', label: 'Navigate' },
+        { keys: 'Enter', label: 'Switch' },
+        { keys: 'Ctrl+B/Esc', label: 'Close' },
+      ]),
+    );
+  });
+
+  it('marks the focused row with the selection indicator', () => {
+    const { lastFrame } = render(
+      <ExecutionWorkspaceSwitcher
+        snapshot={makeSnapshot()}
+        selectedEntryId="main:session_1"
+        onSelect={vi.fn()}
+        onClose={vi.fn()}
+      />,
+    );
+    expect(lastFrame()!).toContain(`${SELECTION_INDICATOR}`);
+  });
+});

package/src/__tests__/execution-workspace-view-model.test.ts

@@ -0,0 +1,94 @@
+import { describe, expect, it } from 'vitest';
+import type {
+  IExecutionWorkspaceEntry,
+  IExecutionWorkspaceSnapshot,
+} from '@robota-sdk/agent-interface-execution';
+import {
+  countActiveBackgroundWorkspaceEntries,
+  formatExecutionDetailRecord,
+  formatExecutionWorkspaceEntryRow,
+  getDefaultBackgroundWorkspaceEntries,
+} from '../execution-workspace-view-model.js';
+
+function makeEntry(overrides: Partial<IExecutionWorkspaceEntry>): IExecutionWorkspaceEntry {
+  return {
+    id: 'task:agent_1',
+    sourceId: 'agent_1',
+    kind: 'background_task',
+    origin: { kind: 'slash_command', sessionId: 'session_1', commandName: 'agent' },
+    taskKind: 'agent',
+    status: 'running',
+    state: 'working',
+    title: 'Explore',
+    subtitle: 'general-purpose',
+    preview: 'Map the CLI state manager',
+    unread: false,
+    attention: 'none',
+    visibility: 'default',
+    updatedAt: '2026-05-09T00:00:00.000Z',
+    controls: ['select', 'cancel'],
+    ...overrides,
+  };
+}
+
+function makeSnapshot(entries: readonly IExecutionWorkspaceEntry[]): IExecutionWorkspaceSnapshot {
+  return {
+    sessionId: 'session_1',
+    selectedEntryId: 'main:session_1',
+    updatedAt: '2026-05-09T00:00:00.000Z',
+    entries,
+  };
+}
+
+describe('execution workspace view model', () => {
+  it('renders selected and inactive entries with radio markers', () => {
+    const row = formatExecutionWorkspaceEntryRow(makeEntry({ id: 'task:agent_1' }), {
+      selectedEntryId: 'task:agent_1',
+    });
+    const inactive = formatExecutionWorkspaceEntryRow(makeEntry({ id: 'task:process_1' }), {
+      selectedEntryId: 'task:agent_1',
+    });
+
+    expect(row.radio).toBe('●');
+    expect(row.title).toBe('Explore agent');
+    expect(row.subtitle).toBe('agent · general-purpose');
+    expect(row.statusLabel).toBe('running');
+    expect(inactive.radio).toBe('○');
+  });
+
+  it('filters default-visible background task entries for the compact panel', () => {
+    const snapshot = makeSnapshot([
+      makeEntry({ id: 'main:session_1', kind: 'main_thread', title: 'Main thread' }),
+      makeEntry({ id: 'task:agent_1', visibility: 'default' }),
+      makeEntry({ id: 'task:agent_2', visibility: 'collapsed' }),
+      makeEntry({ id: 'group:group_1', kind: 'background_group', visibility: 'default' }),
+    ]);
+
+    expect(getDefaultBackgroundWorkspaceEntries(snapshot).map((entry) => entry.id)).toEqual([
+      'task:agent_1',
+    ]);
+  });
+
+  it('counts active default-visible background tasks without treating collapsed tasks as active', () => {
+    const snapshot = makeSnapshot([
+      makeEntry({ id: 'task:queued', status: 'queued' }),
+      makeEntry({ id: 'task:running', status: 'running' }),
+      makeEntry({ id: 'task:permission', status: 'waiting_permission' }),
+      makeEntry({ id: 'task:done', status: 'completed' }),
+      makeEntry({ id: 'task:hidden', status: 'running', visibility: 'collapsed' }),
+    ]);
+
+    expect(countActiveBackgroundWorkspaceEntries(snapshot)).toBe(3);
+  });
+
+  it('bounds detail record text without parsing runner-specific output', () => {
+    const text = formatExecutionDetailRecord({
+      id: 'record_1',
+      kind: 'process_output',
+      text: ` ${'a'.repeat(180)} `,
+    });
+
+    expect(text).toHaveLength(163);
+    expect(text.endsWith('...')).toBe(true);
+  });
+});

package/src/__tests__/external-prompt-notice.test.tsx

@@ -0,0 +1,100 @@
+/**
+ * FLOW-2006 TC-05 — the provenance notice and the consumed-once prefill.
+ *
+ * The notice is what keeps a prompt the user never typed from reading like one they did, and the
+ * consumed-once rule is why a handoff remount cannot re-seed a prompt they already cleared.
+ */
+import { render } from 'ink-testing-library';
+import React from 'react';
+import { describe, expect, it, vi } from 'vitest';
+
+import InputArea from '../InputArea.js';
+import ExternalPromptNotice, {
+  externalPromptNotice,
+  EXTERNAL_PROMPT_NOTICE,
+  EXTERNAL_PROMPT_REVIEW_THRESHOLD,
+} from '../external-prompt-notice.js';
+
+const delay = (): Promise<void> => new Promise((resolve) => setTimeout(resolve, 20));
+
+describe('externalPromptNotice', () => {
+  it('labels a prompt, escalates a long one, and says nothing about an empty composer', () => {
+    expect(externalPromptNotice('hi')).toBe(EXTERNAL_PROMPT_NOTICE);
+    expect(externalPromptNotice('')).toBeUndefined();
+    const long = 'x'.repeat(EXTERNAL_PROMPT_REVIEW_THRESHOLD + 1);
+    const escalated = externalPromptNotice(long) ?? '';
+    expect(escalated).toContain(EXTERNAL_PROMPT_NOTICE);
+    expect(escalated).toContain(String(long.length));
+    expect(escalated).toContain('review');
+    // Exactly at the threshold is still the plain label.
+    expect(externalPromptNotice('x'.repeat(EXTERNAL_PROMPT_REVIEW_THRESHOLD))).toBe(
+      EXTERNAL_PROMPT_NOTICE,
+    );
+  });
+});
+
+describe('ExternalPromptNotice', () => {
+  it('renders the line while the prompt is there and nothing once it is gone', () => {
+    const withPrompt = render(<ExternalPromptNotice value="from a link" />);
+    expect(withPrompt.lastFrame()).toContain(EXTERNAL_PROMPT_NOTICE);
+    const cleared = render(<ExternalPromptNotice value="" />);
+    expect(cleared.lastFrame() ?? '').not.toContain(EXTERNAL_PROMPT_NOTICE);
+  });
+});
+
+/**
+ * The consumed-once contract and the provenance lifetime, driven through the REAL composer.
+ *
+ * A hand-copied stand-in would keep passing if `InputArea`'s own seeding changed — which is the one
+ * thing these assertions exist to catch — so every case below mounts the shipped component.
+ */
+describe('the prefill is consumed once, and the label belongs to that text', () => {
+  it('seeds the composer, tells the controller, and drops the label once the text changes', async () => {
+    const consume = vi.fn();
+    const { lastFrame, stdin } = render(
+      <InputArea
+        onSubmit={vi.fn()}
+        isDisabled={false}
+        initialValue="from a link"
+        consumeInitialValue={consume}
+        externalPromptOrigin
+      />,
+    );
+    await delay();
+    expect(lastFrame()).toContain('from a link');
+    expect(lastFrame()).toContain(EXTERNAL_PROMPT_NOTICE);
+    expect(consume).toHaveBeenCalledTimes(1);
+
+    // The user edits: what is in the composer is no longer what the link supplied, so the
+    // provenance line goes with it. A label that outlived the text would mark the user's own words.
+    stdin.write('!');
+    await delay();
+    expect(lastFrame()).toContain('from a link!');
+    expect(lastFrame() ?? '').not.toContain(EXTERNAL_PROMPT_NOTICE);
+  });
+
+  it('does not re-seed on the handoff remount, after the controller dropped the value', async () => {
+    const consume = vi.fn();
+    const remounted = render(
+      <InputArea
+        onSubmit={vi.fn()}
+        isDisabled={false}
+        initialValue={undefined}
+        consumeInitialValue={consume}
+        externalPromptOrigin
+      />,
+    );
+    await delay();
+    expect(remounted.lastFrame() ?? '').not.toContain(EXTERNAL_PROMPT_NOTICE);
+    expect(consume).not.toHaveBeenCalled();
+  });
+
+  it('never labels a prompt the user typed themselves', async () => {
+    const { lastFrame, stdin } = render(<InputArea onSubmit={vi.fn()} isDisabled={false} />);
+    await delay();
+    stdin.write('my own prompt');
+    await delay();
+    expect(lastFrame()).toContain('my own prompt');
+    expect(lastFrame() ?? '').not.toContain(EXTERNAL_PROMPT_NOTICE);
+  });
+});

package/src/__tests__/fixtures/command-handoff-driver.tsx

@@ -0,0 +1,111 @@
+/**
+ * TEST-007 / TERM-003 + TERM-004 fixture: run the real `/shell` and `/editor` command executors
+ * through the real `TerminalHandoffController` on a real PTY.
+ *
+ * A real Ink app (input hooks below a suspend gate, like the App) provides the live handoff; a minimal
+ * host context wires the executors' three touch-points (`canHandoffTerminal` / `runWithTerminal` /
+ * `getCwd`) to the controller. The session command-pipeline integration is already covered by the
+ * framework functional tests with a fake handoff — this fixture exercises the one thing only a real
+ * terminal can: the controller releasing raw mode so the child (subshell / `$EDITOR`) owns the TTY,
+ * and `runWithTerminal` returning so the TUI resumes.
+ *
+ * argv: [mode ('shell'|'editor'), outputPath, commandArg?]. Markers: `@@READY canHandoff=…@@`,
+ * `@@CMD_DONE@@`, `@@INPUT_AFTER_HANDOFF …@@`. A JSON result
+ * `{ success, exitCode?, message }` is written to outputPath.
+ */
+import { writeFileSync } from 'node:fs';
+
+import { executeEditorCommand, executeShellCommand } from '@robota-sdk/agent-command';
+import { createTestCommandHost } from '@robota-sdk/agent-framework/testing';
+import { Box, Text, render, useInput } from 'ink';
+import React from 'react';
+
+import { useTerminalHandoffSuspension } from '../../hooks/useTerminalHandoffSuspension.js';
+import { TerminalHandoffController } from '../../terminal-handoff-controller.js';
+
+import type {
+  ICommandHostTerminalHandoff,
+  ICommandHostWorkspace,
+} from '@robota-sdk/agent-framework';
+
+const MODE = process.argv[2];
+const OUTPUT_PATH = process.argv[3];
+const COMMAND_ARG = process.argv[4] ?? '';
+
+const controller = new TerminalHandoffController();
+let resolveInputAfterHandoff: ((input: string) => void) | undefined;
+
+/** Minimal host context — the shell/editor executors only read these three members. */
+const context = {
+  canHandoffTerminal: (): boolean => controller.canHandoffTerminal,
+  runWithTerminal: <T,>(fn: () => Promise<T>): Promise<T> => controller.runWithTerminal(fn),
+  getCwd: (): string => process.cwd(),
+} satisfies ICommandHostTerminalHandoff & Pick<ICommandHostWorkspace, 'getCwd'>;
+
+function InputCapture(): React.ReactElement {
+  useInput((input) => resolveInputAfterHandoff?.(input));
+  return <Text>READY</Text>;
+}
+
+function CommandApp(): React.ReactElement {
+  const suspended = useTerminalHandoffSuspension(controller);
+  if (suspended) return <Box />;
+  return (
+    <Box>
+      <InputCapture />
+    </Box>
+  );
+}
+
+function marker(line: string): void {
+  process.stdout.write(`\r\n@@${line}@@\r\n`);
+}
+
+function writeResult(result: Record<string, string | number | boolean | undefined>): void {
+  if (OUTPUT_PATH) writeFileSync(OUTPUT_PATH, JSON.stringify(result), 'utf8');
+}
+
+async function main(): Promise<void> {
+  const instance = render(<CommandApp />);
+  controller.setInkInstance(instance);
+  await new Promise((resolve) => setTimeout(resolve, 300));
+  marker(`READY canHandoff=${controller.canHandoffTerminal}`);
+
+  // ARCH-029: the fixture's `satisfies Pick<>` above is the honest part — it declares exactly the
+  // three members these executors read. The widening cast existed only because the executors demand
+  // the whole 46-member facade. S3's role ports remove the need to widen at all; until then the
+  // double supplies the rest so no cast is required.
+  const ctx = createTestCommandHost({ overrides: context });
+  const result =
+    MODE === 'editor'
+      ? await executeEditorCommand(ctx, COMMAND_ARG)
+      : await executeShellCommand(ctx, COMMAND_ARG);
+
+  marker('CMD_DONE');
+  const inputAfterHandoff = await new Promise<string>((resolve) => {
+    resolveInputAfterHandoff = resolve;
+  });
+  marker(`INPUT_AFTER_HANDOFF ${inputAfterHandoff}`);
+  instance.unmount();
+  await new Promise((resolve) => setTimeout(resolve, 150));
+
+  writeResult({
+    success: result.success,
+    message: result.message,
+    exitCode: (result.data as { exitCode?: number } | undefined)?.exitCode,
+  });
+  await new Promise((resolve) => setTimeout(resolve, 100));
+  process.exit(0);
+}
+
+process.on('uncaughtException', (error) => {
+  writeResult({ success: false, message: String(error) });
+  process.stdout.write(`\r\n@@ERROR ${String(error)}@@\r\n`);
+  process.exit(1);
+});
+
+void main().catch((error) => {
+  writeResult({ success: false, message: String(error) });
+  process.stdout.write(`\r\n@@ERROR ${String(error)}@@\r\n`);
+  process.exit(1);
+});

package/src/__tests__/fixtures/fake-editor.sh

@@ -0,0 +1,7 @@
+#!/bin/sh
+# TEST-007 fake $EDITOR for the /editor PTY scenario.
+# Invoked as: sh fake-editor.sh <file>. Reads ONE line from the inherited terminal (proving the
+# editor runs on the real TTY under the handoff) and writes it as the file's contents, then exits 0.
+file="$1"
+IFS= read -r line
+printf '%s\n' "$line" > "$file"

package/src/__tests__/fixtures/terminal-handoff-driver.tsx

@@ -0,0 +1,90 @@
+/**
+ * TEST-007 / TERM-002 fixture: real-terminal handoff under a PTY.
+ *
+ * Renders a real Ink app that takes raw mode (useInput) BELOW a suspend gate — exactly like the real
+ * App — and uses the real `TerminalHandoffController` + `useTerminalHandoffSuspension`. It performs an
+ * actual handoff: `runWithTerminal` spawns a child that reads ONE line from the inherited terminal and
+ * echoes it. If Ink released raw mode on suspend, the child receives the driver's keystrokes; after
+ * the child exits, `runWithTerminal` must RETURN and the App must resume.
+ *
+ * Driven by `terminal-handoff-pty-e2e.test.ts`. Markers the harness keys off: `@@READY@@`,
+ * `@@HANDOFF_STARTED@@`, `CHILD_GOT:[...]`, `@@RESUMED exit=N@@`. A JSON result is written to argv[0].
+ */
+import { spawn } from 'node:child_process';
+import { writeFileSync } from 'node:fs';
+
+import { Box, Text, render, useInput } from 'ink';
+import React from 'react';
+
+import { useTerminalHandoffSuspension } from '../../hooks/useTerminalHandoffSuspension.js';
+import { TerminalHandoffController } from '../../terminal-handoff-controller.js';
+
+const OUTPUT_PATH = process.argv[2];
+const controller = new TerminalHandoffController();
+
+/** Input-bearing subtree: useInput lives BELOW the suspend gate, so it unmounts (Ink releases raw
+ *  mode) while suspended — mirrors the real App. */
+function InputCapture(): React.ReactElement {
+  useInput(() => {});
+  return <Text>READY</Text>;
+}
+
+function HandoffApp(): React.ReactElement {
+  const suspended = useTerminalHandoffSuspension(controller);
+  if (suspended) return <Box />;
+  return (
+    <Box>
+      <InputCapture />
+    </Box>
+  );
+}
+
+function marker(line: string): void {
+  process.stdout.write(`\r\n@@${line}@@\r\n`);
+}
+
+function writeResult(result: Record<string, string | number | boolean>): void {
+  if (OUTPUT_PATH) writeFileSync(OUTPUT_PATH, JSON.stringify(result), 'utf8');
+}
+
+async function main(): Promise<void> {
+  const instance = render(<HandoffApp />);
+  controller.setInkInstance(instance);
+
+  // Wait for the App to mount + register its suspend hooks.
+  await new Promise((resolve) => setTimeout(resolve, 300));
+  const canHandoff = controller.canHandoffTerminal;
+  marker(`READY canHandoff=${canHandoff}`);
+
+  const exitCode = await controller.runWithTerminal(async () => {
+    marker('HANDOFF_STARTED');
+    return await new Promise<number>((resolve) => {
+      const child = spawn('sh', ['-c', 'IFS= read -r line; printf "CHILD_GOT:[%s]\\n" "$line"'], {
+        stdio: 'inherit',
+      });
+      child.on('exit', (code) => resolve(code ?? 0));
+    });
+  });
+
+  // If runWithTerminal returned, the App resumed (finally → resume ran). Confirm with a marker.
+  marker(`AFTER_HANDOFF exit=${exitCode}`);
+  instance.unmount();
+  await new Promise((resolve) => setTimeout(resolve, 150));
+  marker(`RESUMED exit=${exitCode}`);
+
+  writeResult({ canHandoff, exitCode, returned: true });
+  await new Promise((resolve) => setTimeout(resolve, 100));
+  process.exit(0);
+}
+
+process.on('uncaughtException', (error) => {
+  writeResult({ error: String(error), returned: false });
+  process.stdout.write(`\r\n@@ERROR ${String(error)}@@\r\n`);
+  process.exit(1);
+});
+
+void main().catch((error) => {
+  writeResult({ error: String(error), returned: false });
+  process.stdout.write(`\r\n@@ERROR ${String(error)}@@\r\n`);
+  process.exit(1);
+});