@vsuryav/agent-sim 0.1.0

package/src/engine/buddy/useBuddyNotification.tsx

@@ -0,0 +1,98 @@
+import { c as _c } from "react/compiler-runtime";
+import { feature } from 'bun:bundle';
+import React, { useEffect } from 'react';
+import { useNotifications } from '../context/notifications.js';
+import { Text } from '../ink.js';
+import { getGlobalConfig } from '../utils/config.js';
+import { getRainbowColor } from '../utils/thinking.js';
+
+// Local date, not UTC — 24h rolling wave across timezones. Sustained Twitter
+// buzz instead of a single UTC-midnight spike, gentler on soul-gen load.
+// Teaser window: April 1-7, 2026 only. Command stays live forever after.
+export function isBuddyTeaserWindow(): boolean {
+  if ("external" === 'ant') return true;
+  const d = new Date();
+  return d.getFullYear() === 2026 && d.getMonth() === 3 && d.getDate() <= 7;
+}
+export function isBuddyLive(): boolean {
+  if ("external" === 'ant') return true;
+  const d = new Date();
+  return d.getFullYear() > 2026 || d.getFullYear() === 2026 && d.getMonth() >= 3;
+}
+function RainbowText(t0) {
+  const $ = _c(2);
+  const {
+    text
+  } = t0;
+  let t1;
+  if ($[0] !== text) {
+    t1 = <>{[...text].map(_temp)}</>;
+    $[0] = text;
+    $[1] = t1;
+  } else {
+    t1 = $[1];
+  }
+  return t1;
+}
+
+// Rainbow /buddy teaser shown on startup when no companion hatched yet.
+// Idle presence and reactions are handled by CompanionSprite directly.
+function _temp(ch, i) {
+  return <Text key={i} color={getRainbowColor(i)}>{ch}</Text>;
+}
+export function useBuddyNotification() {
+  const $ = _c(4);
+  const {
+    addNotification,
+    removeNotification
+  } = useNotifications();
+  let t0;
+  let t1;
+  if ($[0] !== addNotification || $[1] !== removeNotification) {
+    t0 = () => {
+      if (!feature("BUDDY")) {
+        return;
+      }
+      const config = getGlobalConfig();
+      if (config.companion || !isBuddyTeaserWindow()) {
+        return;
+      }
+      addNotification({
+        key: "buddy-teaser",
+        jsx: <RainbowText text="/buddy" />,
+        priority: "immediate",
+        timeoutMs: 15000
+      });
+      return () => removeNotification("buddy-teaser");
+    };
+    t1 = [addNotification, removeNotification];
+    $[0] = addNotification;
+    $[1] = removeNotification;
+    $[2] = t0;
+    $[3] = t1;
+  } else {
+    t0 = $[2];
+    t1 = $[3];
+  }
+  useEffect(t0, t1);
+}
+export function findBuddyTriggerPositions(text: string): Array<{
+  start: number;
+  end: number;
+}> {
+  if (!feature('BUDDY')) return [];
+  const triggers: Array<{
+    start: number;
+    end: number;
+  }> = [];
+  const re = /\/buddy\b/g;
+  let m: RegExpExecArray | null;
+  while ((m = re.exec(text)) !== null) {
+    triggers.push({
+      start: m.index,
+      end: m.index + m[0].length
+    });
+  }
+  return triggers;
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/src/engine/ink/Ansi.tsx

@@ -0,0 +1,292 @@
+import { c as _c } from "react/compiler-runtime";
+import React from 'react';
+import Link from './components/Link.js';
+import Text from './components/Text.js';
+import type { Color } from './styles.js';
+import { type NamedColor, Parser, type Color as TermioColor, type TextStyle } from './termio.js';
+type Props = {
+  children: string;
+  /** When true, force all text to be rendered with dim styling */
+  dimColor?: boolean;
+};
+type SpanProps = {
+  color?: Color;
+  backgroundColor?: Color;
+  dim?: boolean;
+  bold?: boolean;
+  italic?: boolean;
+  underline?: boolean;
+  strikethrough?: boolean;
+  inverse?: boolean;
+  hyperlink?: string;
+};
+
+/**
+ * Component that parses ANSI escape codes and renders them using Text components.
+ *
+ * Use this as an escape hatch when you have pre-formatted ANSI strings from
+ * external tools (like cli-highlight) that need to be rendered in Ink.
+ *
+ * Memoized to prevent re-renders when parent changes but children string is the same.
+ */
+export const Ansi = React.memo(function Ansi(t0) {
+  const $ = _c(12);
+  const {
+    children,
+    dimColor
+  } = t0;
+  if (typeof children !== "string") {
+    let t1;
+    if ($[0] !== children || $[1] !== dimColor) {
+      t1 = dimColor ? <Text dim={true}>{String(children)}</Text> : <Text>{String(children)}</Text>;
+      $[0] = children;
+      $[1] = dimColor;
+      $[2] = t1;
+    } else {
+      t1 = $[2];
+    }
+    return t1;
+  }
+  if (children === "") {
+    return null;
+  }
+  let t1;
+  let t2;
+  if ($[3] !== children || $[4] !== dimColor) {
+    t2 = Symbol.for("react.early_return_sentinel");
+    bb0: {
+      const spans = parseToSpans(children);
+      if (spans.length === 0) {
+        t2 = null;
+        break bb0;
+      }
+      if (spans.length === 1 && !hasAnyProps(spans[0].props)) {
+        t2 = dimColor ? <Text dim={true}>{spans[0].text}</Text> : <Text>{spans[0].text}</Text>;
+        break bb0;
+      }
+      let t3;
+      if ($[7] !== dimColor) {
+        t3 = (span, i) => {
+          const hyperlink = span.props.hyperlink;
+          if (dimColor) {
+            span.props.dim = true;
+          }
+          const hasTextProps = hasAnyTextProps(span.props);
+          if (hyperlink) {
+            return hasTextProps ? <Link key={i} url={hyperlink}><StyledText color={span.props.color} backgroundColor={span.props.backgroundColor} dim={span.props.dim} bold={span.props.bold} italic={span.props.italic} underline={span.props.underline} strikethrough={span.props.strikethrough} inverse={span.props.inverse}>{span.text}</StyledText></Link> : <Link key={i} url={hyperlink}>{span.text}</Link>;
+          }
+          return hasTextProps ? <StyledText key={i} color={span.props.color} backgroundColor={span.props.backgroundColor} dim={span.props.dim} bold={span.props.bold} italic={span.props.italic} underline={span.props.underline} strikethrough={span.props.strikethrough} inverse={span.props.inverse}>{span.text}</StyledText> : span.text;
+        };
+        $[7] = dimColor;
+        $[8] = t3;
+      } else {
+        t3 = $[8];
+      }
+      t1 = spans.map(t3);
+    }
+    $[3] = children;
+    $[4] = dimColor;
+    $[5] = t1;
+    $[6] = t2;
+  } else {
+    t1 = $[5];
+    t2 = $[6];
+  }
+  if (t2 !== Symbol.for("react.early_return_sentinel")) {
+    return t2;
+  }
+  const content = t1;
+  let t3;
+  if ($[9] !== content || $[10] !== dimColor) {
+    t3 = dimColor ? <Text dim={true}>{content}</Text> : <Text>{content}</Text>;
+    $[9] = content;
+    $[10] = dimColor;
+    $[11] = t3;
+  } else {
+    t3 = $[11];
+  }
+  return t3;
+});
+type Span = {
+  text: string;
+  props: SpanProps;
+};
+
+/**
+ * Parse an ANSI string into spans using the termio parser.
+ */
+function parseToSpans(input: string): Span[] {
+  const parser = new Parser();
+  const actions = parser.feed(input);
+  const spans: Span[] = [];
+  let currentHyperlink: string | undefined;
+  for (const action of actions) {
+    if (action.type === 'link') {
+      if (action.action.type === 'start') {
+        currentHyperlink = action.action.url;
+      } else {
+        currentHyperlink = undefined;
+      }
+      continue;
+    }
+    if (action.type === 'text') {
+      const text = action.graphemes.map(g => g.value).join('');
+      if (!text) continue;
+      const props = textStyleToSpanProps(action.style);
+      if (currentHyperlink) {
+        props.hyperlink = currentHyperlink;
+      }
+
+      // Try to merge with previous span if props match
+      const lastSpan = spans[spans.length - 1];
+      if (lastSpan && propsEqual(lastSpan.props, props)) {
+        lastSpan.text += text;
+      } else {
+        spans.push({
+          text,
+          props
+        });
+      }
+    }
+  }
+  return spans;
+}
+
+/**
+ * Convert termio's TextStyle to SpanProps.
+ */
+function textStyleToSpanProps(style: TextStyle): SpanProps {
+  const props: SpanProps = {};
+  if (style.bold) props.bold = true;
+  if (style.dim) props.dim = true;
+  if (style.italic) props.italic = true;
+  if (style.underline !== 'none') props.underline = true;
+  if (style.strikethrough) props.strikethrough = true;
+  if (style.inverse) props.inverse = true;
+  const fgColor = colorToString(style.fg);
+  if (fgColor) props.color = fgColor;
+  const bgColor = colorToString(style.bg);
+  if (bgColor) props.backgroundColor = bgColor;
+  return props;
+}
+
+// Map termio named colors to the ansi: format
+const NAMED_COLOR_MAP: Record<NamedColor, string> = {
+  black: 'ansi:black',
+  red: 'ansi:red',
+  green: 'ansi:green',
+  yellow: 'ansi:yellow',
+  blue: 'ansi:blue',
+  magenta: 'ansi:magenta',
+  cyan: 'ansi:cyan',
+  white: 'ansi:white',
+  brightBlack: 'ansi:blackBright',
+  brightRed: 'ansi:redBright',
+  brightGreen: 'ansi:greenBright',
+  brightYellow: 'ansi:yellowBright',
+  brightBlue: 'ansi:blueBright',
+  brightMagenta: 'ansi:magentaBright',
+  brightCyan: 'ansi:cyanBright',
+  brightWhite: 'ansi:whiteBright'
+};
+
+/**
+ * Convert termio's Color to the string format used by Ink.
+ */
+function colorToString(color: TermioColor): Color | undefined {
+  switch (color.type) {
+    case 'named':
+      return NAMED_COLOR_MAP[color.name] as Color;
+    case 'indexed':
+      return `ansi256(${color.index})` as Color;
+    case 'rgb':
+      return `rgb(${color.r},${color.g},${color.b})` as Color;
+    case 'default':
+      return undefined;
+  }
+}
+
+/**
+ * Check if two SpanProps are equal for merging.
+ */
+function propsEqual(a: SpanProps, b: SpanProps): boolean {
+  return a.color === b.color && a.backgroundColor === b.backgroundColor && a.bold === b.bold && a.dim === b.dim && a.italic === b.italic && a.underline === b.underline && a.strikethrough === b.strikethrough && a.inverse === b.inverse && a.hyperlink === b.hyperlink;
+}
+function hasAnyProps(props: SpanProps): boolean {
+  return props.color !== undefined || props.backgroundColor !== undefined || props.dim === true || props.bold === true || props.italic === true || props.underline === true || props.strikethrough === true || props.inverse === true || props.hyperlink !== undefined;
+}
+function hasAnyTextProps(props: SpanProps): boolean {
+  return props.color !== undefined || props.backgroundColor !== undefined || props.dim === true || props.bold === true || props.italic === true || props.underline === true || props.strikethrough === true || props.inverse === true;
+}
+
+// Text style props without weight (bold/dim) - these are handled separately
+type BaseTextStyleProps = {
+  color?: Color;
+  backgroundColor?: Color;
+  italic?: boolean;
+  underline?: boolean;
+  strikethrough?: boolean;
+  inverse?: boolean;
+};
+
+// Wrapper component that handles bold/dim mutual exclusivity for Text
+function StyledText(t0) {
+  const $ = _c(14);
+  let bold;
+  let children;
+  let dim;
+  let rest;
+  if ($[0] !== t0) {
+    ({
+      bold,
+      dim,
+      children,
+      ...rest
+    } = t0);
+    $[0] = t0;
+    $[1] = bold;
+    $[2] = children;
+    $[3] = dim;
+    $[4] = rest;
+  } else {
+    bold = $[1];
+    children = $[2];
+    dim = $[3];
+    rest = $[4];
+  }
+  if (dim) {
+    let t1;
+    if ($[5] !== children || $[6] !== rest) {
+      t1 = <Text {...rest} dim={true}>{children}</Text>;
+      $[5] = children;
+      $[6] = rest;
+      $[7] = t1;
+    } else {
+      t1 = $[7];
+    }
+    return t1;
+  }
+  if (bold) {
+    let t1;
+    if ($[8] !== children || $[9] !== rest) {
+      t1 = <Text {...rest} bold={true}>{children}</Text>;
+      $[8] = children;
+      $[9] = rest;
+      $[10] = t1;
+    } else {
+      t1 = $[10];
+    }
+    return t1;
+  }
+  let t1;
+  if ($[11] !== children || $[12] !== rest) {
+    t1 = <Text {...rest}>{children}</Text>;
+    $[11] = children;
+    $[12] = rest;
+    $[13] = t1;
+  } else {
+    t1 = $[13];
+  }
+  return t1;
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["React","Link","Text","Color","NamedColor","Parser","TermioColor","TextStyle","Props","children","dimColor","SpanProps","color","backgroundColor","dim","bold","italic","underline","strikethrough","inverse","hyperlink","Ansi","memo","t0","$","_c","t1","String","t2","Symbol","for","bb0","spans","parseToSpans","length","hasAnyProps","props","text","t3","span","i","hasTextProps","hasAnyTextProps","map","content","Span","input","parser","actions","feed","currentHyperlink","action","type","url","undefined","graphemes","g","value","join","textStyleToSpanProps","style","lastSpan","propsEqual","push","fgColor","colorToString","fg","bgColor","bg","NAMED_COLOR_MAP","Record","black","red","green","yellow","blue","magenta","cyan","white","brightBlack","brightRed","brightGreen","brightYellow","brightBlue","brightMagenta","brightCyan","brightWhite","name","index","r","b","a","BaseTextStyleProps","StyledText","rest"],"sources":["Ansi.tsx"],"sourcesContent":["import React from 'react'\nimport Link from './components/Link.js'\nimport Text from './components/Text.js'\nimport type { Color } from './styles.js'\nimport {\n  type NamedColor,\n  Parser,\n  type Color as TermioColor,\n  type TextStyle,\n} from './termio.js'\n\ntype Props = {\n  children: string\n  /** When true, force all text to be rendered with dim styling */\n  dimColor?: boolean\n}\n\ntype SpanProps = {\n  color?: Color\n  backgroundColor?: Color\n  dim?: boolean\n  bold?: boolean\n  italic?: boolean\n  underline?: boolean\n  strikethrough?: boolean\n  inverse?: boolean\n  hyperlink?: string\n}\n\n/**\n * Component that parses ANSI escape codes and renders them using Text components.\n *\n * Use this as an escape hatch when you have pre-formatted ANSI strings from\n * external tools (like cli-highlight) that need to be rendered in Ink.\n *\n * Memoized to prevent re-renders when parent changes but children string is the same.\n */\nexport const Ansi = React.memo(function Ansi({\n  children,\n  dimColor,\n}: Props): React.ReactNode {\n  if (typeof children !== 'string') {\n    return dimColor ? (\n      <Text dim>{String(children)}</Text>\n    ) : (\n      <Text>{String(children)}</Text>\n    )\n  }\n\n  if (children === '') {\n    return null\n  }\n\n  const spans = parseToSpans(children)\n\n  if (spans.length === 0) {\n    return null\n  }\n\n  if (spans.length === 1 && !hasAnyProps(spans[0]!.props)) {\n    return dimColor ? (\n      <Text dim>{spans[0]!.text}</Text>\n    ) : (\n      <Text>{spans[0]!.text}</Text>\n    )\n  }\n\n  const content = spans.map((span, i) => {\n    const hyperlink = span.props.hyperlink\n    // When dimColor is forced, override the span's dim prop\n    if (dimColor) {\n      span.props.dim = true\n    }\n    const hasTextProps = hasAnyTextProps(span.props)\n\n    if (hyperlink) {\n      return hasTextProps ? (\n        <Link key={i} url={hyperlink}>\n          <StyledText\n            color={span.props.color}\n            backgroundColor={span.props.backgroundColor}\n            dim={span.props.dim}\n            bold={span.props.bold}\n            italic={span.props.italic}\n            underline={span.props.underline}\n            strikethrough={span.props.strikethrough}\n            inverse={span.props.inverse}\n          >\n            {span.text}\n          </StyledText>\n        </Link>\n      ) : (\n        <Link key={i} url={hyperlink}>\n          {span.text}\n        </Link>\n      )\n    }\n\n    return hasTextProps ? (\n      <StyledText\n        key={i}\n        color={span.props.color}\n        backgroundColor={span.props.backgroundColor}\n        dim={span.props.dim}\n        bold={span.props.bold}\n        italic={span.props.italic}\n        underline={span.props.underline}\n        strikethrough={span.props.strikethrough}\n        inverse={span.props.inverse}\n      >\n        {span.text}\n      </StyledText>\n    ) : (\n      span.text\n    )\n  })\n\n  return dimColor ? <Text dim>{content}</Text> : <Text>{content}</Text>\n})\n\ntype Span = {\n  text: string\n  props: SpanProps\n}\n\n/**\n * Parse an ANSI string into spans using the termio parser.\n */\nfunction parseToSpans(input: string): Span[] {\n  const parser = new Parser()\n  const actions = parser.feed(input)\n  const spans: Span[] = []\n\n  let currentHyperlink: string | undefined\n\n  for (const action of actions) {\n    if (action.type === 'link') {\n      if (action.action.type === 'start') {\n        currentHyperlink = action.action.url\n      } else {\n        currentHyperlink = undefined\n      }\n      continue\n    }\n\n    if (action.type === 'text') {\n      const text = action.graphemes.map(g => g.value).join('')\n      if (!text) continue\n\n      const props = textStyleToSpanProps(action.style)\n      if (currentHyperlink) {\n        props.hyperlink = currentHyperlink\n      }\n\n      // Try to merge with previous span if props match\n      const lastSpan = spans[spans.length - 1]\n      if (lastSpan && propsEqual(lastSpan.props, props)) {\n        lastSpan.text += text\n      } else {\n        spans.push({ text, props })\n      }\n    }\n  }\n\n  return spans\n}\n\n/**\n * Convert termio's TextStyle to SpanProps.\n */\nfunction textStyleToSpanProps(style: TextStyle): SpanProps {\n  const props: SpanProps = {}\n\n  if (style.bold) props.bold = true\n  if (style.dim) props.dim = true\n  if (style.italic) props.italic = true\n  if (style.underline !== 'none') props.underline = true\n  if (style.strikethrough) props.strikethrough = true\n  if (style.inverse) props.inverse = true\n\n  const fgColor = colorToString(style.fg)\n  if (fgColor) props.color = fgColor\n\n  const bgColor = colorToString(style.bg)\n  if (bgColor) props.backgroundColor = bgColor\n\n  return props\n}\n\n// Map termio named colors to the ansi: format\nconst NAMED_COLOR_MAP: Record<NamedColor, string> = {\n  black: 'ansi:black',\n  red: 'ansi:red',\n  green: 'ansi:green',\n  yellow: 'ansi:yellow',\n  blue: 'ansi:blue',\n  magenta: 'ansi:magenta',\n  cyan: 'ansi:cyan',\n  white: 'ansi:white',\n  brightBlack: 'ansi:blackBright',\n  brightRed: 'ansi:redBright',\n  brightGreen: 'ansi:greenBright',\n  brightYellow: 'ansi:yellowBright',\n  brightBlue: 'ansi:blueBright',\n  brightMagenta: 'ansi:magentaBright',\n  brightCyan: 'ansi:cyanBright',\n  brightWhite: 'ansi:whiteBright',\n}\n\n/**\n * Convert termio's Color to the string format used by Ink.\n */\nfunction colorToString(color: TermioColor): Color | undefined {\n  switch (color.type) {\n    case 'named':\n      return NAMED_COLOR_MAP[color.name] as Color\n    case 'indexed':\n      return `ansi256(${color.index})` as Color\n    case 'rgb':\n      return `rgb(${color.r},${color.g},${color.b})` as Color\n    case 'default':\n      return undefined\n  }\n}\n\n/**\n * Check if two SpanProps are equal for merging.\n */\nfunction propsEqual(a: SpanProps, b: SpanProps): boolean {\n  return (\n    a.color === b.color &&\n    a.backgroundColor === b.backgroundColor &&\n    a.bold === b.bold &&\n    a.dim === b.dim &&\n    a.italic === b.italic &&\n    a.underline === b.underline &&\n    a.strikethrough === b.strikethrough &&\n    a.inverse === b.inverse &&\n    a.hyperlink === b.hyperlink\n  )\n}\n\nfunction hasAnyProps(props: SpanProps): boolean {\n  return (\n    props.color !== undefined ||\n    props.backgroundColor !== undefined ||\n    props.dim === true ||\n    props.bold === true ||\n    props.italic === true ||\n    props.underline === true ||\n    props.strikethrough === true ||\n    props.inverse === true ||\n    props.hyperlink !== undefined\n  )\n}\n\nfunction hasAnyTextProps(props: SpanProps): boolean {\n  return (\n    props.color !== undefined ||\n    props.backgroundColor !== undefined ||\n    props.dim === true ||\n    props.bold === true ||\n    props.italic === true ||\n    props.underline === true ||\n    props.strikethrough === true ||\n    props.inverse === true\n  )\n}\n\n// Text style props without weight (bold/dim) - these are handled separately\ntype BaseTextStyleProps = {\n  color?: Color\n  backgroundColor?: Color\n  italic?: boolean\n  underline?: boolean\n  strikethrough?: boolean\n  inverse?: boolean\n}\n\n// Wrapper component that handles bold/dim mutual exclusivity for Text\nfunction StyledText({\n  bold,\n  dim,\n  children,\n  ...rest\n}: BaseTextStyleProps & {\n  bold?: boolean\n  dim?: boolean\n  children: string\n}): React.ReactNode {\n  // dim takes precedence over bold when both are set (terminals treat them as mutually exclusive)\n  if (dim) {\n    return (\n      <Text {...rest} dim>\n        {children}\n      </Text>\n    )\n  }\n  if (bold) {\n    return (\n      <Text {...rest} bold>\n        {children}\n      </Text>\n    )\n  }\n  return <Text {...rest}>{children}</Text>\n}\n"],"mappings":"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","ignoreList":[]}

package/src/engine/ink/bidi.ts

@@ -0,0 +1,139 @@
+/**
+ * Bidirectional text reordering for terminal rendering.
+ *
+ * Terminals on Windows do not implement the Unicode Bidi Algorithm,
+ * so RTL text (Hebrew, Arabic, etc.) appears reversed. This module
+ * applies the bidi algorithm to reorder ClusteredChar arrays from
+ * logical order to visual order before Ink's LTR cell placement loop.
+ *
+ * On macOS terminals (Terminal.app, iTerm2) bidi works natively.
+ * Windows Terminal (including WSL) does not implement bidi
+ * (https://github.com/microsoft/terminal/issues/538).
+ *
+ * Detection: Windows Terminal sets WT_SESSION; native Windows cmd/conhost
+ * also lacks bidi. We enable bidi reordering when running on Windows or
+ * inside Windows Terminal (covers WSL).
+ */
+import bidiFactory from 'bidi-js'
+
+type ClusteredChar = {
+  value: string
+  width: number
+  styleId: number
+  hyperlink: string | undefined
+}
+
+let bidiInstance: ReturnType<typeof bidiFactory> | undefined
+let needsSoftwareBidi: boolean | undefined
+
+function needsBidi(): boolean {
+  if (needsSoftwareBidi === undefined) {
+    needsSoftwareBidi =
+      process.platform === 'win32' ||
+      typeof process.env['WT_SESSION'] === 'string' || // WSL in Windows Terminal
+      process.env['TERM_PROGRAM'] === 'vscode' // VS Code integrated terminal (xterm.js)
+  }
+  return needsSoftwareBidi
+}
+
+function getBidi() {
+  if (!bidiInstance) {
+    bidiInstance = bidiFactory()
+  }
+  return bidiInstance
+}
+
+/**
+ * Reorder an array of ClusteredChars from logical order to visual order
+ * using the Unicode Bidi Algorithm. Active on terminals that lack native
+ * bidi support (Windows Terminal, conhost, WSL).
+ *
+ * Returns the same array on bidi-capable terminals (no-op).
+ */
+export function reorderBidi(characters: ClusteredChar[]): ClusteredChar[] {
+  if (!needsBidi() || characters.length === 0) {
+    return characters
+  }
+
+  // Build a plain string from the clustered chars to run through bidi
+  const plainText = characters.map(c => c.value).join('')
+
+  // Check if there are any RTL characters — skip bidi if pure LTR
+  if (!hasRTLCharacters(plainText)) {
+    return characters
+  }
+
+  const bidi = getBidi()
+  const { levels } = bidi.getEmbeddingLevels(plainText, 'auto')
+
+  // Map bidi levels back to ClusteredChar indices.
+  // Each ClusteredChar may be multiple code units in the joined string.
+  const charLevels: number[] = []
+  let offset = 0
+  for (let i = 0; i < characters.length; i++) {
+    charLevels.push(levels[offset]!)
+    offset += characters[i]!.value.length
+  }
+
+  // Get reorder segments from bidi-js, but we need to work at the
+  // ClusteredChar level, not the string level. We'll implement the
+  // standard bidi reordering: find the max level, then for each level
+  // from max down to 1, reverse all contiguous runs >= that level.
+  const reordered = [...characters]
+  const maxLevel = Math.max(...charLevels)
+
+  for (let level = maxLevel; level >= 1; level--) {
+    let i = 0
+    while (i < reordered.length) {
+      if (charLevels[i]! >= level) {
+        // Find the end of this run
+        let j = i + 1
+        while (j < reordered.length && charLevels[j]! >= level) {
+          j++
+        }
+        // Reverse the run in both arrays
+        reverseRange(reordered, i, j - 1)
+        reverseRangeNumbers(charLevels, i, j - 1)
+        i = j
+      } else {
+        i++
+      }
+    }
+  }
+
+  return reordered
+}
+
+function reverseRange<T>(arr: T[], start: number, end: number): void {
+  while (start < end) {
+    const temp = arr[start]!
+    arr[start] = arr[end]!
+    arr[end] = temp
+    start++
+    end--
+  }
+}
+
+function reverseRangeNumbers(arr: number[], start: number, end: number): void {
+  while (start < end) {
+    const temp = arr[start]!
+    arr[start] = arr[end]!
+    arr[end] = temp
+    start++
+    end--
+  }
+}
+
+/**
+ * Quick check for RTL characters (Hebrew, Arabic, and related scripts).
+ * Avoids running the full bidi algorithm on pure-LTR text.
+ */
+function hasRTLCharacters(text: string): boolean {
+  // Hebrew: U+0590-U+05FF, U+FB1D-U+FB4F
+  // Arabic: U+0600-U+06FF, U+0750-U+077F, U+08A0-U+08FF, U+FB50-U+FDFF, U+FE70-U+FEFF
+  // Thaana: U+0780-U+07BF
+  // Syriac: U+0700-U+074F
+  return /[\u0590-\u05FF\uFB1D-\uFB4F\u0600-\u06FF\u0750-\u077F\u08A0-\u08FF\uFB50-\uFDFF\uFE70-\uFEFF\u0780-\u07BF\u0700-\u074F]/u.test(
+    text,
+  )
+}

package/src/engine/ink/clearTerminal.ts

@@ -0,0 +1,74 @@
+/**
+ * Cross-platform terminal clearing with scrollback support.
+ * Detects modern terminals that support ESC[3J for clearing scrollback.
+ */
+
+import {
+  CURSOR_HOME,
+  csi,
+  ERASE_SCREEN,
+  ERASE_SCROLLBACK,
+} from './termio/csi.js'
+
+// HVP (Horizontal Vertical Position) - legacy Windows cursor home
+const CURSOR_HOME_WINDOWS = csi(0, 'f')
+
+function isWindowsTerminal(): boolean {
+  return process.platform === 'win32' && !!process.env.WT_SESSION
+}
+
+function isMintty(): boolean {
+  // mintty 3.1.5+ sets TERM_PROGRAM to 'mintty'
+  if (process.env.TERM_PROGRAM === 'mintty') {
+    return true
+  }
+  // GitBash/MSYS2/MINGW use mintty and set MSYSTEM
+  if (process.platform === 'win32' && process.env.MSYSTEM) {
+    return true
+  }
+  return false
+}
+
+function isModernWindowsTerminal(): boolean {
+  // Windows Terminal sets WT_SESSION environment variable
+  if (isWindowsTerminal()) {
+    return true
+  }
+
+  // VS Code integrated terminal on Windows with ConPTY support
+  if (
+    process.platform === 'win32' &&
+    process.env.TERM_PROGRAM === 'vscode' &&
+    process.env.TERM_PROGRAM_VERSION
+  ) {
+    return true
+  }
+
+  // mintty (GitBash/MSYS2/Cygwin) supports modern escape sequences
+  if (isMintty()) {
+    return true
+  }
+
+  return false
+}
+
+/**
+ * Returns the ANSI escape sequence to clear the terminal including scrollback.
+ * Automatically detects terminal capabilities.
+ */
+export function getClearTerminalSequence(): string {
+  if (process.platform === 'win32') {
+    if (isModernWindowsTerminal()) {
+      return ERASE_SCREEN + ERASE_SCROLLBACK + CURSOR_HOME
+    } else {
+      // Legacy Windows console - can't clear scrollback
+      return ERASE_SCREEN + CURSOR_HOME_WINDOWS
+    }
+  }
+  return ERASE_SCREEN + ERASE_SCROLLBACK + CURSOR_HOME
+}
+
+/**
+ * Clears the terminal screen. On supported terminals, also clears scrollback.
+ */
+export const clearTerminal = getClearTerminalSequence()