pi-minimalist 0.2.0 → 0.2.3

package/README.md

@@ -14,11 +14,11 @@ A quieter transcript for [Pi](https://pi.dev): turn bulky tool calls into one-li
 
 <img width="699" height="50" alt="after" src="https://github.com/user-attachments/assets/c0e8bca4-afa7-42c1-9bf0-69f267d18d9f" />
 
-**Click** a folded line to open it into separate rows. Click one row to see only its output.
+**Click** a folded line to open it into separate rows. Click one row to see only its output. Click the `▾ Expanded · click to fold` line above an opened run to fold it back.
 
 <img src="docs/click.png" width="600" alt="Clicking a folded line opens it into rows; clicking one row expands only that row">
 
-Press **Ctrl+O** to expand tool output—including diffs and syntax highlighting. Nothing is removed from the session or hidden from the model; only the display changes.
+Press **Ctrl+O** to expand tool output—including diffs and syntax highlighting. Expanded rows also wrap long commands instead of cutting them off. Nothing is removed from the session or hidden from the model; only the display changes.
 
 ## Install
 
@@ -72,7 +72,7 @@ Settings apply to existing conversation history and are saved globally. If a sym
 
 Turn off **Compact tool rows** to restore native tool cards. Or choose the `off` preset.
 
-To disable the extension completely, run `pi config`, disable pi-minimalist, and restart Pi. To uninstall:
+To disable the extension completely, run `pi config`, disable pi-minimalist, and restart Pi
 
 ## Compatibility
 

package/index.ts

@@ -23,7 +23,7 @@ import { getSettingsListTheme } from "@earendil-works/pi-coding-agent";
 import { SettingsList } from "@earendil-works/pi-tui";
 import { installBridges, sharedState } from "./src/bridge.ts";
 import { type BasicKey, type BasicSettings, type Config } from "./src/config.ts";
-import { customSeed, loadSettings, migratedQuiet, saveBasicSettings } from "./src/config-file.ts";
+import { customSeed, loadSettings, saveBasicSettings } from "./src/config-file.ts";
 import { argumentCompletions, createConfigScreen, summary } from "./src/config-ui.ts";
 import { patchCore } from "./src/core-patch.ts";
 import { refreshMcpTools } from "./src/tools.ts";
@@ -34,15 +34,8 @@ export default function (pi: ExtensionAPI) {
   // strand every row on stale state.
   const { config, grouping } = sharedState(loadSettings());
 
-  // One-time migration of the preference written by the removed `/quiet`
-  // command. A session override, so the per-turn re-read below cannot revert it
-  // before the user has saved anything.
-  const migrated = migratedQuiet();
-  if (migrated !== undefined) config.setSessionOverride("groupToolRuns", migrated);
-
   installBridges({ config, grouping });
-  // Runtime replacement for editing Pi's compiled bundle. Idempotent, so a
-  // /reload only refreshes the bridge slots the wrappers read.
+  // Idempotent, so a /reload only refreshes the Bridge the wrappers read.
   patchCore(core);
 
   const refresh = () => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-minimalist",
-  "version": "0.2.0",
+  "version": "0.2.3",
   "description": "Compact one-line tool and thinking rows for Pi's interactive transcript",
   "keywords": ["pi-package"],
   "license": "MIT",
@@ -16,6 +16,7 @@
     "@earendil-works/pi-tui": "*"
   },
   "pi": {
-    "extensions": ["./index.ts"]
+    "extensions": ["./index.ts"],
+    "image": "https://raw.githubusercontent.com/EviHex/pi-minimalist/main/docs/click.png"
   }
 }

package/src/bridge.ts

@@ -2,56 +2,72 @@
  * The boundary between this extension and Pi's core components.
  *
  * Nothing on disk is patched. `core-patch.ts` wraps Pi's real component
- * prototypes at load time and READS the process-global slots below at CALL time,
- * so `/reload` swaps behavior without re-wrapping anything, and an unloaded
- * extension degrades to Pi's native rendering.
+ * prototypes at load time and READS ONE process-global object, the `Bridge`
+ * below, at CALL time. Every install replaces that object as a whole, so
+ * `/reload` swaps behavior without re-wrapping anything, and an unloaded
+ * extension (no object) degrades to Pi's native rendering.
  *
- * SINGLE SOURCE OF TRUTH for the symbol names, shared by the wrappers, the state
- * that must survive `/reload`, and the tests.
+ * SINGLE SOURCE OF TRUTH for the global key names, shared by the wrappers, the
+ * state that must survive `/reload`, and the tests.
  */
 
 import { Config } from "./config.ts";
 import { RunGrouping } from "./run-grouping.ts";
-import { Painter, type ThemeLike } from "./row.ts";
-import { createToolRenderer } from "./tool-renderer.ts";
-import { createThinkingPreview, singleHueThinkingTheme } from "./thinking.ts";
+import { Painter, type Row, type ThemeLike } from "./row.ts";
+import { createToolRenderer, type ToolRenderer } from "./tool-renderer.ts";
+import { createThinkingPreview, singleHueThinkingTheme, type ThinkingPreview } from "./thinking.ts";
 import type { Timers } from "./components.ts";
 
 export const BRIDGE_SYMBOLS = {
-  /** `{ renderShell, handles, renderCall, renderResult }` for every tool row. */
-  toolRenderer: "pi.defaultToolRenderer",
-  /** `(text, theme, pad, streaming, owner, runIndex) => Component`. */
-  thinkingPreview: "pi.thinkingPreview",
-  /** `(markdownTheme, theme) => markdownTheme` for expanded thinking. */
-  thinkingMarkdownTheme: "pi.thinkingMarkdownTheme",
-
+  /** The `Bridge` object: everything the prototype wrappers call. */
+  bridge: "pi.minimalist.bridge",
   /** Live settings, retained across a /reload. */
   config: "pi.minimalist.config",
   /** Run-grouping state, retained across a /reload. */
   grouping: "pi.minimalist.grouping",
+} as const;
+
+/**
+ * What the prototype wrappers may call. Functions, not values: the wrappers read
+ * the object on every call, so a settings toggle takes effect without
+ * reinstalling anything.
+ */
+export type Bridge = {
+  /** `{ renderShell, handles, renderCall, renderResult }` for every tool row. */
+  toolRenderer: ToolRenderer;
+  thinkingPreview: ThinkingPreview;
+  /** Expanded thinking: the Markdown theme with every token in the thinking hue. */
+  thinkingMarkdownTheme: (base: Record<string, unknown>, theme: ThemeLike) => Record<string, unknown>;
+  /** `thinkingAsToolCall`: do collapsed/expanded thinking rows belong to us? */
+  compactThinking: () => boolean;
+  /** Keep a STREAMING thinking block expanded. */
+  keepActiveThinkingExpanded: () => boolean;
 
   /** Chronology hooks that keep thinking and prose in transcript order. */
-  observeThinking: "pi.minimalist.observeThinking",
-  observeProse: "pi.minimalist.observeProse",
+  observeThinking: (owner: object, runIndex: number, streaming: boolean, hidden: boolean, timestamp?: number) => string;
+  observeProse: RunGrouping["observeProse"];
+  /** A visible row we do not fold (user message, excluded tool); it cuts runs. */
+  observeBarrier: (id: string) => void;
   /** `undefined` = native prose, `null` = hidden, Row = folded summary. */
-  proseView: "pi.minimalist.proseView",
-  /** `(toolCallId) => boolean`: omit core's separator before an activity summary. */
-  activitySummaryRow: "pi.minimalist.activitySummaryRow",
-  /** `(owner) => normal|hidden|summary`: normalize assistant host spacing. */
-  activityMessageView: "pi.minimalist.activityMessageView",
+  proseView: (id: string, theme: ThemeLike) => Row | null | undefined;
+  /** Header of an opened run, drawn by a prose/native-thinking host. */
+  proseHeader: (id: string, theme: ThemeLike) => Row | undefined;
+  /** A click on a summary or header; true when handled. */
+  click: (id: string, onHeader: boolean) => boolean;
+  /** Omit core's separator before an activity summary. */
+  activitySummaryRow: (id: string) => boolean;
+  /** Normalize assistant host spacing. */
+  activityMessageView: (owner: object) => "normal" | "hidden" | "summary";
   /**
    * Spacer suppression for a fully hidden assistant message.
    *
    * There is deliberately NO tool-row equivalent: a compact row uses
    * `renderShell: "self"`, and core's self-shell branch emits its separator
    * inline and returns ZERO lines when the row renders nothing — spacer
-   * included. An earlier `quietSpacer` bridge was compensating for a problem core
-   * already handles.
+   * included.
    */
-  messageSpacer: "pi.minimalist.messageSpacer",
-  /** `() => boolean`: keep a STREAMING thinking block expanded. */
-  keepActiveThinkingExpanded: "pi.minimalist.keepActiveThinkingExpanded",
-} as const;
+  messageSpacer: (owner: object) => boolean;
+};
 
 type Globals = Record<symbol, unknown>;
 
@@ -59,6 +75,11 @@ function slot(key: keyof typeof BRIDGE_SYMBOLS): symbol {
   return Symbol.for(BRIDGE_SYMBOLS[key]);
 }
 
+/** The installed bridge, or `undefined` when the extension is not loaded. */
+export function readBridge(): Bridge | undefined {
+  return (globalThis as Globals)[slot("bridge")] as Bridge | undefined;
+}
+
 /**
  * State that must survive `/reload`.
  *
@@ -85,40 +106,40 @@ export type InstallOptions = SharedState & {
 };
 
 /**
- * Install every bridge.
+ * Install the bridge.
  *
- * Each `/reload` overwrites these slots with fresh instances. Do NOT clear them
+ * Each `/reload` overwrites the slots with fresh instances. Do NOT clear them
  * from `session_shutdown`: reload ordering can let an old shutdown hook erase the
- * newly installed bridges. Process exit clears globalThis naturally.
+ * newly installed bridge. Process exit clears globalThis naturally.
  */
 export function installBridges({ config, grouping, timers }: InstallOptions): void {
   const globals = globalThis as Globals;
+  const painter = (theme: ThemeLike) => new Painter(theme, config);
 
-  globals[slot("config")] = config;
-  globals[slot("grouping")] = grouping;
-  globals[slot("toolRenderer")] = createToolRenderer({ config, grouping, timers });
-  globals[slot("thinkingPreview")] = createThinkingPreview({ config, grouping, timers });
-  globals[slot("thinkingMarkdownTheme")] = (base: Record<string, unknown>, theme: never) =>
-    singleHueThinkingTheme(base, theme, config);
+  const bridge: Bridge = {
+    toolRenderer: createToolRenderer({ config, grouping, timers }),
+    thinkingPreview: createThinkingPreview({ config, grouping, timers }),
+    thinkingMarkdownTheme: (base, theme) => singleHueThinkingTheme(base, theme, config),
+    compactThinking: () => config.get("thinkingAsToolCall") === true,
+    keepActiveThinkingExpanded: () => config.get("keepActiveThinkingExpanded"),
 
-  // Chronology: core walks message content in transcript order, and run folding
-  // depends on that order.
-  globals[slot("observeThinking")] = (owner: object, runIndex: number, streaming: boolean, hidden: boolean) => {
-    grouping.observeThinking(owner, runIndex, !streaming, !hidden);
-    return grouping.thinkingId(owner, runIndex);
+    // Chronology: core walks message content in transcript order, and run
+    // folding depends on that order.
+    observeThinking: (owner, runIndex, streaming, hidden, timestamp) => {
+      grouping.observeThinking(owner, runIndex, !streaming, !hidden, timestamp);
+      return grouping.thinkingId(owner, runIndex);
+    },
+    observeProse: (owner, contentIndex, signal) => grouping.observeProse(owner, contentIndex, signal),
+    observeBarrier: (id) => grouping.observeBarrier(id),
+    proseView: (id, theme) => grouping.proseView(id, painter(theme)),
+    proseHeader: (id, theme) => grouping.headerFor(id, painter(theme)),
+    click: (id, onHeader) => grouping.click(id, onHeader),
+    activitySummaryRow: (id) => grouping.isActivitySummary(id),
+    activityMessageView: (owner) => grouping.activityMessageView(owner),
+    messageSpacer: (owner) => grouping.showsMessageSpacer(owner),
   };
-  globals[slot("observeProse")] = (
-    owner: object,
-    contentIndex: number,
-    signal: Parameters<RunGrouping["observeProse"]>[2],
-  ) => grouping.observeProse(owner, contentIndex, signal);
-  globals[slot("proseView")] = (id: string, theme: ThemeLike) =>
-    grouping.proseView(id, new Painter(theme, config));
-  globals[slot("activitySummaryRow")] = (id: string) => grouping.isActivitySummary(id);
-  globals[slot("activityMessageView")] = (owner: object) => grouping.activityMessageView(owner);
-  globals[slot("messageSpacer")] = (owner: object) => grouping.showsMessageSpacer(owner);
 
-  // A function, not a value: the prototype wrapper reads it on every call, so a
-  // toggle takes effect without reinstalling anything.
-  globals[slot("keepActiveThinkingExpanded")] = () => config.get("keepActiveThinkingExpanded");
+  globals[slot("config")] = config;
+  globals[slot("grouping")] = grouping;
+  globals[slot("bridge")] = bridge;
 }

package/src/components.ts

@@ -6,7 +6,7 @@
  * production components without loading an extension runtime.
  */
 
-import { truncateToWidth } from "@earendil-works/pi-tui";
+import { truncateToWidth, visibleWidth, wrapTextWithAnsi } from "@earendil-works/pi-tui";
 import type { Component, TuiMouseEvent, TuiMouseEventResult } from "@earendil-works/pi-tui";
 import { gutterWidth, type Row } from "./row.ts";
 
@@ -40,17 +40,57 @@ export const realTimers: Timers = {
  */
 export type ResolveRow = (width: number) => Row | null;
 
+/** Columns the details must keep on each line before wrapping is worth it. */
+const MIN_WRAP_COLUMNS = 10;
+
+/**
+ * An expanded row's details wrapped under themselves (a hanging indent below
+ * `glyph label`), or undefined when the terminal is too narrow to wrap
+ * usefully: the caller then truncates as usual. A body that fits wraps to a
+ * single line.
+ */
+function wrapped({ head, body }: { head: string; body: string }, room: number): string[] | undefined {
+  const indent = visibleWidth(head) + 1;
+  if (room - indent < MIN_WRAP_COLUMNS) return undefined;
+  const pad = " ".repeat(indent);
+  return wrapTextWithAnsi(body, room - indent).map((line, i) => (i === 0 ? `${head} ` : pad) + line);
+}
+
 /**
- * One physical terminal line with width-aware truncation and full-width color.
+ * Paint a resolved row at `width`; `null` renders ZERO lines.
+ *
+ * TUI pads each line to terminal width, so no manual trailing padding is
+ * needed. truncateToWidth understands ANSI codes and wide Unicode glyphs, so
+ * colored text truncates at VISIBLE columns. The gutter is a fixed-width
+ * prefix, so the content gets the remaining columns. Width comes from the
+ * row's OWN gutter text, so a disabled gutter reclaims those columns.
+ */
+function renderRow(row: Row | null, width: number): string[] {
+  if (row === null) return [];
+  const room = Math.max(1, width - gutterWidth(row.gutter));
+  const paint = (line: string) => row.gutter + line;
+  const lines = row.wrap ? wrapped(row.wrap, room) : undefined;
+  if (lines) return lines.map(paint);
+  return [paint(truncateToWidth(row.text, room, "…"))];
+}
+
+/**
+ * One physical terminal line (several for an expanded row) with width-aware
+ * truncation and full-width color.
  *
  * Pi's Text component wraps long strings. That is correct for prose but made a
- * long path spill onto a second line in a supposedly single-line renderer. TUI
+ * long path spill onto a second line in a renderer meant for one line. TUI
  * only supplies the real terminal width during render(), so truncating with a
  * fixed character count in the caller cannot solve this reliably.
+ *
+ * The one exception is an EXPANDED row (`row.wrap`): there the user asked to see
+ * everything, so a long command wraps under its own details instead.
  */
 export class CompactLine implements Component {
   private resolve: ResolveRow = () => null;
-  private click?: () => boolean;
+  private click?: (onHeader: boolean) => boolean;
+  /** Did the last render draw a header line at y=0? */
+  private headed = false;
   private ticker: unknown;
   private timers: Timers;
 
@@ -60,9 +100,10 @@ export class CompactLine implements Component {
 
   /**
    * Install the row resolver. Called on every updateDisplay with fresh state.
-   * `click` returning true stops Pi's own left-click (expand) handler.
+   * `click` returning true stops Pi's own left-click (expand) handler; its
+   * argument says whether the click landed on the row's header line.
    */
-  setRow(resolve: ResolveRow, click?: () => boolean): void {
+  setRow(resolve: ResolveRow, click?: (onHeader: boolean) => boolean): void {
     this.resolve = resolve;
     this.click = click;
   }
@@ -71,7 +112,8 @@ export class CompactLine implements Component {
   // the region's own expand/collapse toggle.
   handleMouse(event: TuiMouseEvent): TuiMouseEventResult | undefined {
     if (event.type !== "click" || event.button !== "left") return undefined;
-    return this.click?.() ? { handled: true } : undefined;
+    // `y` is local to THIS component (Container subtracts earlier siblings).
+    return this.click?.(this.headed && event.y === 0) ? { handled: true } : undefined;
   }
 
   /**
@@ -91,22 +133,10 @@ export class CompactLine implements Component {
     }
   }
 
-  /** Test/inspection helper: is a repaint interval currently registered? */
-  isTicking(): boolean {
-    return this.ticker !== undefined;
-  }
-
   render(width: number): string[] {
     const row = this.resolve(width);
-    if (row === null) return [];
-
-    // TUI pads each line to terminal width, so no manual trailing padding is
-    // needed. truncateToWidth understands ANSI codes and wide Unicode glyphs,
-    // so colored text truncates at VISIBLE columns. The gutter is a fixed-width
-    // prefix, so the content gets the remaining columns. Width comes from the
-    // row's OWN gutter text, so a disabled gutter reclaims those columns.
-    const line = truncateToWidth(row.text, Math.max(1, width - gutterWidth(row.gutter)), "…");
-    return [row.gutter + (row.highlight ? row.highlight(line) : line)];
+    this.headed = row?.header !== undefined;
+    return [...(row?.header ? [...renderRow(row.header, width), ""] : []), ...renderRow(row, width)];
   }
 
   // Component contract allows cached components to be invalidated. This class
@@ -115,28 +145,55 @@ export class CompactLine implements Component {
 }
 
 /**
- * Collapsed results must render ZERO lines, not one blank line.
- *
- * Pi's Text component returns [""] for empty strings (one blank row), which
- * doubled the height of every collapsed tool call. This is the only safe way to
- * say "no content at all" while still returning a Component, as the
- * renderResult slot contract requires.
+ * Assistant prose or native thinking that a fold may take over: the resolver
+ * returns a Row to draw it instead, `null` to hide it (zero lines), or
+ * `undefined` to leave `inner` untouched (with an opened run's header line
+ * above it, when `header` supplies one). The header is followed by one blank line. Clicks on the summary or header go to
+ * `click`.
  */
 export class FoldableProse implements Component {
   private inner: Component;
   private resolve: (width: number) => Row | null | undefined;
+  private header: () => Row | undefined;
+  private click: (onHeader: boolean) => boolean;
+  /** What the last render drew: a folded summary, or a header line above native output. */
+  private summary = false;
+  private headed = false;
 
-  constructor(inner: Component, resolve: (width: number) => Row | null | undefined) {
+  /**
+   * `header` is the opened-run header to draw above the native output; `click`
+   * has the same contract as `CompactLine.setRow`'s: it gets whether the click
+   * landed on that header line.
+   */
+  constructor(
+    inner: Component,
+    resolve: (width: number) => Row | null | undefined,
+    header: () => Row | undefined,
+    click: (onHeader: boolean) => boolean,
+  ) {
     this.inner = inner;
     this.resolve = resolve;
+    this.header = header;
+    this.click = click;
   }
 
   render(width: number): string[] {
     const row = this.resolve(width);
-    if (row === undefined) return this.inner.render(width);
-    const line = new CompactLine();
-    line.setRow(() => row);
-    return line.render(width);
+    this.summary = row !== undefined && row !== null;
+    const header = row === undefined ? this.header() : undefined;
+    this.headed = header !== undefined;
+    if (row !== undefined) return renderRow(row, width);
+    return header ? [...renderRow(header, width), "", ...this.inner.render(width)] : this.inner.render(width);
+  }
+
+  // Only the summary or the header line is clickable; the native output below
+  // keeps whatever click behavior its own host (e.g. a thinking MouseRegion) has.
+  // `y` is local to THIS component, like CompactLine's.
+  handleMouse(event: TuiMouseEvent): TuiMouseEventResult | undefined {
+    if (event.type !== "click" || event.button !== "left") return undefined;
+    const onHeader = this.headed && event.y === 0;
+    if (!this.summary && !onHeader) return undefined;
+    return this.click(onHeader) ? { handled: true } : undefined;
   }
 
   invalidate(): void {
@@ -144,6 +201,14 @@ export class FoldableProse implements Component {
   }
 }
 
+/**
+ * Collapsed results must render ZERO lines, not one blank line.
+ *
+ * Pi's Text component returns [""] for empty strings (one blank row), which
+ * doubled the height of every collapsed tool call. This is the only safe way to
+ * say "no content at all" while still returning a Component, as the
+ * renderResult slot contract requires.
+ */
 export class EmptyComponent implements Component {
   render(): string[] {
     return [];

package/src/config-file.ts

@@ -3,12 +3,9 @@
  *
  * WHY settings.json AND NOT OUR OWN FILE
  * --------------------------------------
- * The old `pi-minimalist.json` was a second config file the user had to know
- * about, and it hardcoded `~/.pi/agent`, so anyone setting
- * `PI_CODING_AGENT_DIR` silently wrote their preference somewhere it would never
- * be read back. settings.json is where a Pi user already looks, it is what
- * `pi-env` reads, and Pi tolerates unknown top-level keys (the published
- * `pi-powerline-footer` extension does exactly this with its `powerline` key).
+ * It is where a Pi user already looks, it is what `pi-env` reads, and Pi
+ * tolerates unknown top-level keys (the published `pi-powerline-footer`
+ * extension does exactly this with its `powerline` key).
  *
  * SCOPE
  *   defaults  <  global agent settings.json (PI_CODING_AGENT_DIR if set).
@@ -57,11 +54,6 @@ export function globalSettingsPath(env = process.env): string {
   return join(agentDir(env), "settings.json");
 }
 
-/** Legacy state file written by the removed `/quiet` command. */
-export function legacyQuietPath(env = process.env): string {
-  return join(agentDir(env), "pi-minimalist.json");
-}
-
 type Json = Record<string, unknown>;
 
 function isRecord(value: unknown): value is Json {
@@ -75,59 +67,12 @@ function isRecord(value: unknown): value is Json {
 /**
  * Remove `//` and block comments that are outside string literals.
  *
- * Pi bundles `strip-json-comments` but does not re-export it to extensions, so
- * this is a small character scanner. The only real subtlety is that `//` inside a
- * JSON string (a URL, a Windows path) must NOT start a comment.
+ * Pi bundles `strip-json-comments` but does not re-export it to extensions. The
+ * regex matches a whole string first (escapes included) and keeps it, so `//`
+ * inside a URL or path never starts a comment.
  */
 export function stripJsonComments(text: string): string {
-  let out = "";
-  let inString = false;
-  let escaped = false;
-  let comment: "line" | "block" | undefined;
-
-  for (let i = 0; i < text.length; i++) {
-    const char = text[i];
-    const next = text[i + 1];
-
-    if (comment === "line") {
-      if (char === "\n") {
-        comment = undefined;
-        out += char;
-      }
-      continue;
-    }
-    if (comment === "block") {
-      if (char === "*" && next === "/") {
-        comment = undefined;
-        i++;
-      }
-      continue;
-    }
-    if (inString) {
-      out += char;
-      if (escaped) escaped = false;
-      else if (char === "\\") escaped = true;
-      else if (char === '"') inString = false;
-      continue;
-    }
-    if (char === '"') {
-      inString = true;
-      out += char;
-      continue;
-    }
-    if (char === "/" && next === "/") {
-      comment = "line";
-      i++;
-      continue;
-    }
-    if (char === "/" && next === "*") {
-      comment = "block";
-      i++;
-      continue;
-    }
-    out += char;
-  }
-  return out;
+  return text.replace(/("(?:\\.|[^"\\])*")|\/\/[^\n]*|\/\*[\s\S]*?\*\//g, (_, string) => string ?? "");
 }
 
 /** True when a file carries comments, so writing it back would destroy them. */
@@ -191,9 +136,6 @@ function coerce(raw: unknown, into: Settings): Settings {
     // therefore the honest boundary of what this function can check.
     out.tokens = pickStrings(raw.tokens, Object.keys(DEFAULT_TOKENS) as (keyof Tokens)[]) as Partial<Tokens>;
   }
-  if (typeof raw.maxDetailChars === "number" && raw.maxDetailChars > 0) {
-    out.maxDetailChars = Math.floor(raw.maxDetailChars);
-  }
   return out;
 }
 
@@ -223,24 +165,6 @@ export function customSeed(env = process.env): Record<string, boolean> | undefin
   return own ? undefined : PRESETS.lite;
 }
 
-/**
- * One-time migration of the old `/quiet` preference.
- *
- * Returns a value only when settings.json has no `groupToolRuns` yet, so an
- * explicit new setting always wins and a stale legacy file cannot resurrect a
- * preference the user has since changed.
- */
-export function migratedQuiet(env = process.env): boolean | undefined {
-  const existing = readSettingsFile(globalSettingsPath(env))[SETTINGS_KEY];
-  if (isRecord(existing) && typeof existing.groupToolRuns === "boolean") return undefined;
-  try {
-    const legacy = JSON.parse(readFileSync(legacyQuietPath(env), "utf8"));
-    return isRecord(legacy) && legacy.quiet === true ? true : undefined;
-  } catch {
-    return undefined;
-  }
-}
-
 // ---------------------------------------------------------------------------
 // Writing
 // ---------------------------------------------------------------------------

package/src/config-ui.ts

@@ -42,12 +42,6 @@ export const FIELDS: Field[] = [
     label: "Collapse earlier activity",
     description: "Keep the latest assistant reply visible; replace earlier text, thinking, and tool calls with one summary.",
   },
-  {
-    key: "foldActivityOnFinalAnswer",
-    label: "  Collapse when final answer starts",
-    description: "Keep work visible until OpenAI starts its final answer, then collapse the earlier activity.",
-    activityOption: true,
-  },
   {
     key: "activitySummary",
     label: "  Activity summary",