@golba98/codexa 1.0.1

package/src/ui/layout.ts

@@ -0,0 +1,287 @@
+/**
+ * Responsive layout constants and hook.
+ *
+ * Three modes based purely on terminal column count:
+ *
+ *   full    ≥ 110 cols  → full banner, side-by-side header info
+ *   compact  60–109     → single-line mini logo, stacked info, condensed composer
+ *   micro    < 60       → no logo, one-line header, ultra-compact composer
+ */
+
+import { useEffect, useRef, useState } from "react";
+import { useStdout } from "ink";
+import stringWidth from "string-width";
+import * as renderDebug from "../core/perf/renderDebug.js";
+
+export const BREAKPOINT_FULL    = 110; // ≥ this → full
+export const BREAKPOINT_COMPACT =  60; // ≥ this → compact; below → micro
+export const MIN_VIEWPORT_COLS = 20;
+export const MIN_VIEWPORT_ROWS = 10;
+export const RESTORE_SETTLE_MS = 100;
+export const STARTUP_TINY_MIN_COLS = 40;
+export const STARTUP_TINY_MIN_ROWS = 14;
+export const STARTUP_FULL_MIN_COLS = BREAKPOINT_FULL;
+export const STARTUP_FULL_MIN_BODY_ROWS = 4;
+export const STARTUP_FULL_SAFE_PADDING_ROWS = 1;
+export const STARTUP_COMPACT_INTRO_ROWS = 4;
+export const STARTUP_TINY_MESSAGE_ROWS = 3;
+export const transcriptContentIndent = 4; // 2 for DashCard border + 2 for prompt prefix
+const DEFAULT_COLUMNS = 120;
+const DEFAULT_ROWS = 24;
+
+export type LayoutMode = "full" | "compact" | "micro";
+export type StartupHeaderMode = "large" | "compact" | "tiny";
+
+export interface Layout {
+  cols: number;
+  rows: number;
+  mode: LayoutMode;
+}
+
+export interface TerminalViewport extends Layout {
+  rawCols?: number;
+  rawRows?: number;
+  unstable: boolean;
+  layoutEpoch: number;
+}
+
+// ─── Dimension helpers ────────────────────────────────────────────────────────
+
+function isValidDimension(value: number | undefined): value is number {
+  return typeof value === "number" && Number.isFinite(value) && value > 0;
+}
+
+export function normalizeDimension(value: number | undefined, fallback: number): number {
+  if (!isValidDimension(value)) {
+    // If even the fallback is invalid, use an absolute floor.
+    return isValidDimension(fallback) ? Math.floor(fallback) : 10;
+  }
+
+  return Math.floor(value);
+}
+
+export function isRenderableViewport(cols: number | undefined, rows: number | undefined): boolean {
+  return isValidDimension(cols)
+    && isValidDimension(rows)
+    && Math.floor(cols) >= MIN_VIEWPORT_COLS
+    && Math.floor(rows) >= MIN_VIEWPORT_ROWS;
+}
+
+/**
+ * Leave a 1-column gutter so box-drawing borders never land exactly on the
+ * terminal edge, which can trigger a horizontal scrollbar in some Windows hosts.
+ */
+export function getShellWidth(cols: number | undefined): number {
+  return Math.max(20, (cols ?? 120) - 1);
+}
+
+export function getUsableShellWidth(cols: number | undefined, reservedColumns = 0): number {
+  return Math.max(1, getShellWidth(cols) - reservedColumns);
+}
+
+/**
+ * Leave a 1-row gutter so renders do not land exactly on the terminal bottom
+ * edge, which can trigger viewport scroll drift in some hosts.
+ */
+export function getShellHeight(rows: number | undefined): number {
+  return Math.max(10, (rows ?? DEFAULT_ROWS) - 1);
+}
+
+export interface StartupHeaderModeParams {
+  cols: number | undefined;
+  rows: number | undefined;
+  introRows: number;
+  composerRows: number;
+}
+
+export function resolveStartupHeaderMode({
+  cols,
+  rows,
+  introRows,
+  composerRows,
+}: StartupHeaderModeParams): StartupHeaderMode {
+  const safeCols = normalizeDimension(cols, DEFAULT_COLUMNS);
+  const safeRows = normalizeDimension(rows, DEFAULT_ROWS);
+
+  if (safeCols < STARTUP_TINY_MIN_COLS || safeRows < STARTUP_TINY_MIN_ROWS) {
+    return "tiny";
+  }
+
+  const shellHeight = getShellHeight(safeRows);
+  const fullStartupRows = introRows
+    + composerRows
+    + STARTUP_FULL_MIN_BODY_ROWS
+    + STARTUP_FULL_SAFE_PADDING_ROWS;
+
+  if (safeCols >= STARTUP_FULL_MIN_COLS && shellHeight >= fullStartupRows) {
+    return "large";
+  }
+
+  return "compact";
+}
+
+export function getVisualWidth(text: string): number {
+  return stringWidth(text);
+}
+
+export function clampVisualText(text: string, maxWidth: number): string {
+  if (maxWidth <= 0) return "";
+  if (getVisualWidth(text) <= maxWidth) return text;
+
+  const ellipsis = maxWidth > 1 ? "…" : "";
+  const suffixWidth = getVisualWidth(ellipsis);
+  let output = "";
+
+  for (const char of Array.from(text)) {
+    if (getVisualWidth(output + char) + suffixWidth > maxWidth) {
+      break;
+    }
+    output += char;
+  }
+
+  return output + ellipsis;
+}
+
+function computeMode(cols: number): LayoutMode {
+  if (cols >= BREAKPOINT_FULL)    return "full";
+  if (cols >= BREAKPOINT_COMPACT) return "compact";
+  return "micro";
+}
+
+export function createLayoutSnapshot(
+  cols: number | undefined,
+  rows: number | undefined,
+  fallback: Layout = {
+    cols: DEFAULT_COLUMNS,
+    rows: DEFAULT_ROWS,
+    mode: computeMode(DEFAULT_COLUMNS),
+  },
+): Layout {
+  const nextCols = normalizeDimension(cols, fallback.cols);
+  const nextRows = normalizeDimension(rows, fallback.rows);
+
+  return {
+    cols: nextCols,
+    rows: nextRows,
+    mode: computeMode(nextCols),
+  };
+}
+
+function snapshot(stdout: NodeJS.WriteStream, fallback?: Layout): Layout {
+  return createLayoutSnapshot(stdout.columns, stdout.rows, fallback);
+}
+
+export function createTerminalViewport(
+  cols: number | undefined,
+  rows: number | undefined,
+  fallback?: TerminalViewport,
+): TerminalViewport {
+  const fallbackLayout = fallback
+    ? { cols: fallback.cols, rows: fallback.rows, mode: fallback.mode }
+    : undefined;
+  const unstable = !isRenderableViewport(cols, rows);
+  const stableLayout = unstable && fallbackLayout
+    ? fallbackLayout
+    : createLayoutSnapshot(cols, rows, fallbackLayout);
+
+  return {
+    ...stableLayout,
+    rawCols: cols,
+    rawRows: rows,
+    unstable,
+    layoutEpoch: fallback?.layoutEpoch ?? 0,
+  };
+}
+
+export function advanceTerminalViewport(
+  current: TerminalViewport,
+  cols: number | undefined,
+  rows: number | undefined,
+): TerminalViewport {
+  const next = createTerminalViewport(cols, rows, current);
+  if (!next.unstable && current.unstable) {
+    return {
+      ...next,
+      layoutEpoch: current.layoutEpoch + 1,
+    };
+  }
+
+  return {
+    ...next,
+    layoutEpoch: current.layoutEpoch,
+  };
+}
+
+// ─── Hook ────────────────────────────────────────────────────────────────────
+
+/** React hook — returns live layout that ignores transient invalid restore sizes. */
+export function useTerminalViewport(): TerminalViewport {
+  const { stdout } = useStdout();
+  const [viewport, setViewport] = useState<TerminalViewport>(() => createTerminalViewport(stdout.columns, stdout.rows));
+  const settleTimerRef = useRef<ReturnType<typeof setTimeout> | null>(null);
+
+  useEffect(() => {
+    const commit = () => {
+      setViewport((current) => {
+        const nextViewport = advanceTerminalViewport(current, stdout.columns, stdout.rows);
+        if (
+          current.cols === nextViewport.cols &&
+          current.rows === nextViewport.rows &&
+          current.mode === nextViewport.mode &&
+          current.unstable === nextViewport.unstable &&
+          current.layoutEpoch === nextViewport.layoutEpoch &&
+          current.rawCols === nextViewport.rawCols &&
+          current.rawRows === nextViewport.rawRows
+        ) {
+          renderDebug.traceFlickerEvent("measurementUpdate", {
+            result: "skipped",
+            cols: nextViewport.cols,
+            rows: nextViewport.rows,
+            mode: nextViewport.mode,
+            unstable: nextViewport.unstable,
+          });
+          return current;
+        }
+
+        renderDebug.traceFlickerEvent("measurementUpdate", {
+          result: "updated",
+          cols: nextViewport.cols,
+          rows: nextViewport.rows,
+          mode: nextViewport.mode,
+          unstable: nextViewport.unstable,
+        });
+        return nextViewport;
+      });
+    };
+
+    const onResize = () => {
+      renderDebug.traceEvent("terminal", "viewportHookResize", {
+        cols: stdout.columns,
+        rows: stdout.rows,
+        renderable: isRenderableViewport(stdout.columns, stdout.rows),
+      });
+      renderDebug.traceLayoutValidity("useTerminalViewport", {
+        rawCols: stdout.columns,
+        rawRows: stdout.rows,
+      });
+      commit();
+      if (settleTimerRef.current) {
+        clearTimeout(settleTimerRef.current);
+      }
+      settleTimerRef.current = setTimeout(() => {
+        settleTimerRef.current = null;
+        commit();
+      }, RESTORE_SETTLE_MS);
+    };
+
+    stdout.on("resize", onResize);
+    return () => {
+      stdout.off("resize", onResize);
+      if (settleTimerRef.current) {
+        clearTimeout(settleTimerRef.current);
+      }
+    };
+  }, [stdout]);
+
+  return viewport;
+}

package/src/ui/modeDisplay.test.ts

@@ -0,0 +1,42 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+import { getModeDisplaySpec } from "./modeDisplay.js";
+import { THEMES, theme } from "./theme.js";
+
+test("maps internal modes to Codex-aligned display labels", () => {
+  assert.equal(getModeDisplaySpec("suggest", theme).label, "Read-only");
+  assert.equal(getModeDisplaySpec("auto-edit", theme).label, "Auto");
+  assert.equal(getModeDisplaySpec("full-auto", theme).label, "Full Access");
+});
+
+test("uses distinct ring glyphs and theme tokens for each mode", () => {
+  const readOnly = getModeDisplaySpec("suggest", theme);
+  const auto = getModeDisplaySpec("auto-edit", theme);
+  const fullAccess = getModeDisplaySpec("full-auto", theme);
+
+  assert.equal(readOnly.ringGlyph, "○");
+  assert.equal(readOnly.ringColor, theme.SUCCESS);
+  assert.equal(readOnly.ringFill, theme.PANEL_SOFT);
+
+  assert.equal(auto.ringGlyph, "◎");
+  assert.equal(auto.ringColor, theme.BORDER_ACTIVE);
+  assert.equal(auto.ringFill, theme.PANEL_ALT);
+
+  assert.equal(fullAccess.ringGlyph, "◉");
+  assert.equal(fullAccess.ringColor, theme.WARNING);
+  assert.equal(fullAccess.ringFill, theme.BORDER_SUBTLE);
+});
+
+test("keeps the mode ring meaningful across every built-in theme", () => {
+  for (const [themeName, activeTheme] of Object.entries(THEMES)) {
+    const specs = [
+      getModeDisplaySpec("suggest", activeTheme),
+      getModeDisplaySpec("auto-edit", activeTheme),
+      getModeDisplaySpec("full-auto", activeTheme),
+    ];
+
+    assert.equal(new Set(specs.map((spec) => spec.ringGlyph)).size, 3, themeName);
+    assert.equal(new Set(specs.map((spec) => spec.ringColor)).size, 3, themeName);
+    assert.ok(specs.every((spec) => spec.ringFill.length > 0), themeName);
+  }
+});

package/src/ui/modeDisplay.ts

@@ -0,0 +1,52 @@
+import { formatModeLabel } from "../config/settings.js";
+import type { Theme } from "./theme.js";
+
+export interface ModeDisplaySpec {
+  label: string;
+  ringGlyph: string;
+  ringColor: string;
+  ringFill: string;
+  iconColor: string;
+  labelColor: string;
+  labelBold: boolean;
+  ringBold: boolean;
+}
+
+export function getModeDisplaySpec(mode: string, theme: Theme): ModeDisplaySpec {
+  switch (mode) {
+    case "full-auto":
+      return {
+        label: formatModeLabel(mode),
+        ringGlyph: "◉",
+        ringColor: theme.WARNING,
+        ringFill: theme.BORDER_SUBTLE,
+        iconColor: theme.WARNING,
+        labelColor: theme.TEXT,
+        labelBold: true,
+        ringBold: true,
+      };
+    case "auto-edit":
+      return {
+        label: formatModeLabel(mode),
+        ringGlyph: "◎",
+        ringColor: theme.BORDER_ACTIVE,
+        ringFill: theme.PANEL_ALT,
+        iconColor: theme.PROMPT,
+        labelColor: theme.TEXT,
+        labelBold: true,
+        ringBold: false,
+      };
+    case "suggest":
+    default:
+      return {
+        label: formatModeLabel(mode),
+        ringGlyph: "○",
+        ringColor: theme.SUCCESS,
+        ringFill: theme.PANEL_SOFT,
+        iconColor: theme.SUCCESS,
+        labelColor: theme.MUTED,
+        labelBold: false,
+        ringBold: false,
+      };
+  }
+}

package/src/ui/outputPipeline.ts

@@ -0,0 +1,64 @@
+import { isNoiseLine } from "../core/providers/codexTranscript.js";
+import { sanitizeTerminalOutput } from "../core/terminal/terminalSanitize.js";
+import { parseMarkdown, type Segment } from "./Markdown.js";
+
+/**
+ * Sanitize: Strip ANSI escape sequences and non-printable control characters.
+ * Removes known UI chrome bleed (e.g. box drawing characters) before rendering.
+ *
+ * Note on diff colours: Diff colouring in this app is applied at the React/Ink
+ * rendering layer via getDiffTone() tones, NOT via raw ANSI escape sequences.
+ * This means sanitizeTerminalOutput() can safely strip all raw ANSI here —
+ * the correct theme colours are re-applied by buildCodePanelRows/buildMarkdownRows
+ * in timelineMeasure.ts. There is no need to preserve SGR codes at this stage.
+ */
+export function sanitizeOutput(raw: string): string {
+  if (!raw) return "";
+  const clean = sanitizeTerminalOutput(raw, { preserveTabs: false, tabSize: 2 });
+  return clean;
+}
+
+/**
+ * Sanitize streamed chunks directly (delegates to sanitizeOutput).
+ */
+export function sanitizeStreamChunk(chunk: string): string {
+  return sanitizeOutput(chunk);
+}
+
+/**
+ * Normalize: Normalizes text formatting for the box wrappers.
+ * Replaces CRLF with LF and collapses excessive blank lines to prevent
+ * vertical stretching and layout popping.
+ */
+export function normalizeOutput(clean: string): string {
+  let normalized = clean.replace(/\r\n/g, "\n").replace(/\r/g, "\n");
+  // Collapse excessive vertical whitespace (4+ newlines into 3)
+  normalized = normalized.replace(/\n{4,}/g, "\n\n\n");
+
+  // Remove lines that are purely known noise prefixes
+  const lines = normalized.split("\n");
+  const filteredLines = lines.filter((line) => !isNoiseLine(line));
+
+  return filteredLines.join("\n");
+}
+
+/**
+ * Classify: Segments the normalized string into typed semantic blocks
+ * such as prose, code blocks, diffs, lists, and headers.
+ *
+ * Diff colouring is applied at render time via getDiffTone() in
+ * timelineMeasure.ts, which maps each diff line to a TimelineTone that
+ * the theme system resolves to the correct terminal colour.
+ */
+export function classifyOutput(normalized: string): Segment[] {
+  return parseMarkdown(normalized);
+}
+
+/**
+ * Format For Box: Intentional pass-through — segments are returned as-is.
+ * Width-fitting is handled downstream by the layout engine in timelineMeasure.ts.
+ * This function exists as a named pipeline stage for clarity and future extension.
+ */
+export function formatForBox(classified: Segment[], boxWidth: number): Segment[] {
+  return classified;
+}

package/src/ui/progressEntries.ts

@@ -0,0 +1,156 @@
+import type { RunProgressBlock, RunProgressEntry, RunProgressSource } from "../session/types.js";
+import { sanitizeTerminalOutput } from "../core/terminal/terminalSanitize.js";
+import { wrapPlainText } from "./textLayout.js";
+
+// ─── Types ───────────────────────────────────────────────────────────────────
+
+export interface VisibleProgressBlock {
+  id: string;
+  key: string;
+  label: string;
+  headline: string;
+  text: string;
+  source: RunProgressSource;
+  entryId: string;
+  entrySequence: number;
+  blockSequence: number;
+  status: RunProgressBlock["status"];
+  isLatest: boolean;
+  isActive: boolean;
+}
+
+export interface VisibleProgressBlocks {
+  hiddenCount: number;
+  totalCount: number;
+  blocks: VisibleProgressBlock[];
+  latestBlock: VisibleProgressBlock | null;
+  latestActiveBlock: VisibleProgressBlock | null;
+}
+
+// ─── Block selection ─────────────────────────────────────────────────────────
+
+function sourceLabel(source: RunProgressSource): string {
+  switch (source) {
+    case "reasoning":
+      return "Reasoning";
+    case "todo":
+      return "Todo";
+    case "tool":
+      return "Tool";
+    case "activity":
+      return "Activity";
+    case "stderr":
+      return "Process";
+    case "transcript":
+      return "Progress";
+    default:
+      return "Update";
+  }
+}
+
+function firstMeaningfulLine(text: string): string {
+  return sanitizeTerminalOutput(text)
+    .replace(/\r\n/g, "\n")
+    .replace(/\r/g, "\n")
+    .split("\n")
+    .map((line) => line.trim())
+    .find(Boolean) ?? "";
+}
+
+function buildProgressHeadline(source: RunProgressSource, text: string, status: RunProgressBlock["status"]): string {
+  const label = status === "active" ? "Current" : sourceLabel(source);
+  const firstLine = firstMeaningfulLine(text);
+  return firstLine ? `${label}: ${firstLine}` : label;
+}
+
+function toVisibleProgressBlocks(entries: RunProgressEntry[]): VisibleProgressBlock[] {
+  const blocks: VisibleProgressBlock[] = [];
+  let visibleSequence = 0;
+
+  for (const entry of entries) {
+    for (const block of entry.blocks) {
+      if (!block.text.trim()) continue;
+      visibleSequence += 1;
+      blocks.push({
+        id: block.id,
+        key: block.id,
+        label: `Update ${visibleSequence}`,
+        headline: buildProgressHeadline(entry.source, block.text, block.status),
+        text: block.text,
+        source: entry.source,
+        entryId: entry.id,
+        entrySequence: entry.sequence,
+        blockSequence: block.sequence,
+        status: block.status,
+        isLatest: false,
+        isActive: block.status === "active",
+      });
+    }
+  }
+
+  return blocks.map((block, index) => ({
+    ...block,
+    isLatest: index === blocks.length - 1,
+  }));
+}
+
+export function getProgressUpdateCount(entries: RunProgressEntry[]): number {
+  return toVisibleProgressBlocks(entries).length;
+}
+
+export function selectVisibleProgressBlocks(entries: RunProgressEntry[], maxVisible: number): VisibleProgressBlocks {
+  const blocks = toVisibleProgressBlocks(entries);
+  const safeMax = Math.max(0, maxVisible);
+  const findLatestActiveBlock = (candidates: VisibleProgressBlock[]): VisibleProgressBlock | null => {
+    for (let index = candidates.length - 1; index >= 0; index -= 1) {
+      if (candidates[index]?.isActive) {
+        return candidates[index]!;
+      }
+    }
+    return null;
+  };
+
+  if (blocks.length <= safeMax) {
+    return {
+      hiddenCount: 0,
+      totalCount: blocks.length,
+      blocks,
+      latestBlock: blocks[blocks.length - 1] ?? null,
+      latestActiveBlock: findLatestActiveBlock(blocks),
+    };
+  }
+
+  const visible = blocks.slice(-safeMax);
+  return {
+    hiddenCount: blocks.length - safeMax,
+    totalCount: blocks.length,
+    blocks: visible,
+    latestBlock: visible[visible.length - 1] ?? null,
+    latestActiveBlock: findLatestActiveBlock(visible),
+  };
+}
+
+export function formatProgressBlockBodyLines(text: string, width: number): string[] {
+  const contentWidth = Math.max(1, width);
+  const normalized = sanitizeTerminalOutput(text)
+    .replace(/\r\n/g, "\n")
+    .replace(/\r/g, "\n")
+    .replace(/[ \t]+\n/g, "\n");
+
+  if (!normalized.trim()) {
+    return [" "];
+  }
+
+  const rows: string[] = [];
+  for (const rawLine of normalized.split("\n")) {
+    if (!rawLine.trim()) {
+      rows.push("");
+      continue;
+    }
+
+    const wrapped = wrapPlainText(rawLine, contentWidth);
+    rows.push(...(wrapped.length > 0 ? wrapped : [" "]));
+  }
+
+  return rows.length > 0 ? rows : [" "];
+}

package/src/ui/runActivityView.test.ts

@@ -0,0 +1,89 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+import type { RunEvent } from "../session/types.js";
+import { summarizeRunActivity } from "../core/workspaceActivity.js";
+import { TEST_RUNTIME } from "../test/runtimeTestUtils.js";
+import {
+  formatRunActivityStats,
+  getVisibleRawOutputLines,
+  selectVisibleRunActivity,
+  shouldShowRawOutputFallback,
+} from "./runActivityView.js";
+
+function makeRunEvent(overrides: Partial<RunEvent> = {}): RunEvent {
+  const activity = overrides.activity ?? [];
+  return {
+    id: 1,
+    type: "run",
+    createdAt: 1,
+    startedAt: 1,
+    durationMs: null,
+    backendId: "codex-subprocess",
+    backendLabel: "Codex CLI",
+    runtime: TEST_RUNTIME,
+    prompt: "Build something",
+    progressEntries: [],
+    status: "running",
+    summary: "Running",
+    truncatedOutput: false,
+    toolActivities: overrides.toolActivities ?? [],
+    activity,
+    touchedFileCount: overrides.touchedFileCount ?? new Set(activity.map((item) => item.path)).size,
+    activitySummary: overrides.activitySummary ?? summarizeRunActivity(activity),
+    errorMessage: null,
+    turnId: overrides.turnId ?? 1,
+    ...overrides,
+  };
+}
+
+test("does not surface raw output fallback while a run is active", () => {
+  const event = makeRunEvent({
+    progressEntries: [],
+    activity: [{ path: "src/app.tsx", operation: "modified", detectedAt: 1 }],
+  });
+
+  assert.equal(shouldShowRawOutputFallback(event), false);
+  assert.deepEqual(getVisibleRawOutputLines(event), []);
+});
+
+test("keeps raw output hidden even when no structured activity exists yet", () => {
+  const event = makeRunEvent({
+    progressEntries: [],
+  });
+
+  assert.equal(shouldShowRawOutputFallback(event), false);
+  assert.deepEqual(getVisibleRawOutputLines(event), []);
+});
+
+test("keeps only the compact recent activity for completed runs", () => {
+  const activity = Array.from({ length: 6 }, (_, index) => ({
+    path: `src/file-${index}.ts`,
+    operation: "modified" as const,
+    detectedAt: index,
+  }));
+  const event = makeRunEvent({
+    status: "completed",
+    activity,
+    activitySummary: summarizeRunActivity(activity),
+  });
+
+  const { visible, hiddenCount } = selectVisibleRunActivity(event);
+  assert.equal(visible.length, 4);
+  assert.equal(hiddenCount, 2);
+  assert.equal(visible[0]?.path, "src/file-2.ts");
+});
+
+test("formats touched-file stats for the run card header", () => {
+  const activity = [
+    { path: "README.md", operation: "created" as const, detectedAt: 1 },
+    { path: "src/app.tsx", operation: "modified" as const, detectedAt: 2 },
+    { path: "old.txt", operation: "deleted" as const, detectedAt: 3 },
+  ];
+  const event = makeRunEvent({
+    activity,
+    touchedFileCount: 3,
+    activitySummary: summarizeRunActivity(activity),
+  });
+
+  assert.equal(formatRunActivityStats(event), "3 files touched  +1  ~1  -1");
+});