@groeponline/pi-wishcraft 1.4.16 → 1.4.17

package/CHANGELOG.md

@@ -2,6 +2,17 @@
 
 ## [Unreleased]
 
+## [1.4.17] - 2026-09-07
+
+### Added
+- Bash forward-mode privacy notice (issue #71): the first keystroke forwarded to a running command raises an info notice that typed input may echo into the transcript; documented in `docs/bash-mode.md`.
+- Managed PTY suite is now script-gated (issue #73): PTY-core tests skip when `script(1)` is missing instead of silently passing in degraded pipe mode, the basic run asserts a real PTY transport, and the explicit pipe-mode tests still cover the fallback.
+
+### Fixed
+- Bash paste-while-running (issue #72): a bracketed paste performed while a command runs is stripped of its markers and forwarded to the child stdin — including split delivery across input chunks — instead of silently queuing in the editor buffer behind the command.
+- PTY/transcript memory bounds (from jan `fix/runtime-pty-bounds`): a single unterminated output line is capped at a 64 KiB UTF-8 tail with a one-time notice, the partial-escape tail is bounded, and the active transcript command trims head lines/bytes within limits instead of growing unbounded.
+- Segment-options spread hygiene (CodeFactor #86–89): `normalizeSegmentOptions` assigns fields imperatively instead of spreading conditional empty objects.
+
 ## [1.4.16] - 2026-09-05
 
 ### Fixed

package/bash-mode/editor.ts

@@ -31,6 +31,24 @@ import type {
   GhostSuggestion,
 } from "./types.ts";
 
+const BRACKETED_PASTE_START = "\x1b[200~";
+const BRACKETED_PASTE_END = "\x1b[201~";
+
+function splitTrailingPasteMarkerPrefix(value: string): [string, string] {
+  let tail = "";
+  for (const marker of [BRACKETED_PASTE_START, BRACKETED_PASTE_END]) {
+    const max = Math.min(marker.length - 1, value.length);
+    for (let length = max; length > tail.length; length -= 1) {
+      const candidate = value.slice(-length);
+      if (marker.startsWith(candidate)) {
+        tail = candidate;
+        break;
+      }
+    }
+  }
+  return tail ? [value.slice(0, -tail.length), tail] : [value, ""];
+}
+
 export class BashModeEditor extends CustomEditor {
   private readonly keybindingsRef: KeybindingsManager;
   private readonly optionsRef: BashModeEditorOptions;
@@ -43,6 +61,10 @@ export class BashModeEditor extends CustomEditor {
   private ghostAbort: AbortController | null = null;
   private ghostToken = 0;
   private ghostSchedule: ReturnType<typeof setTimeout> | null = null;
+  /** A bracketed paste was split across input chunks while forwarding. */
+  private forwardPasteOpen = false;
+  /** Trailing prefix of a bracketed-paste delimiter awaiting the next input chunk. */
+  private forwardPasteMarkerTail = "";
 
   constructor(
     tui: any,
@@ -112,6 +134,25 @@ export class BashModeEditor extends CustomEditor {
   }
 
   handleInput(data: string): void {
+    // v2 forward-mode gate, shared by the paste branch (issue #72) and the
+    // per-keystroke forward further down: while a command runs, input
+    // belongs to the child stdin, never to the editor buffer behind it.
+    const forwardActive =
+      this.optionsRef.isBashModeActive() &&
+      this.optionsRef.isShellRunning() &&
+      (this.optionsRef.forwardWhileRunning?.() ?? false) &&
+      this.optionsRef.onForwardInput != null;
+    if (!forwardActive) {
+      this.forwardPasteOpen = false;
+      this.forwardPasteMarkerTail = "";
+    } else {
+      data = this.forwardPasteMarkerTail + data;
+      const [complete, tail] = splitTrailingPasteMarkerPrefix(data);
+      data = complete;
+      this.forwardPasteMarkerTail = tail;
+      if (!data) return;
+    }
+
     const droppedPathText = droppedPathTextFromInput(data);
     if (droppedPathText !== null) {
       this.insertTextAtCursor(droppedPathText);
@@ -125,8 +166,23 @@ export class BashModeEditor extends CustomEditor {
     }
 
     const pasteInProgress =
-      data.includes("\x1b[200~") || Reflect.get(this, "isInPaste") === true;
+      data.includes(BRACKETED_PASTE_START) ||
+      data.includes(BRACKETED_PASTE_END) ||
+      Reflect.get(this, "isInPaste") === true ||
+      (forwardActive && this.forwardPasteOpen);
     if (pasteInProgress) {
+      if (forwardActive) {
+        const startIndex = data.lastIndexOf(BRACKETED_PASTE_START);
+        const endIndex = data.lastIndexOf(BRACKETED_PASTE_END);
+        if (startIndex !== -1 || endIndex !== -1) {
+          this.forwardPasteOpen = startIndex > endIndex;
+        }
+        const payload = data
+          .replaceAll(BRACKETED_PASTE_START, "")
+          .replaceAll(BRACKETED_PASTE_END, "");
+        if (payload) this.optionsRef.onForwardInput?.(payload);
+        return;
+      }
       super.handleInput(data);
       if (Reflect.get(this, "isInPaste") === true) {
         return;
@@ -169,15 +225,14 @@ export class BashModeEditor extends CustomEditor {
       // (\x04) must also forward — line-oriented stdin programs (read,
       // sudo, git rebase -i) cannot proceed without a line terminator.
       // Opt-in via forwardWhileRunning so v1 run-blocked behavior unchanged.
+      // (forwardActive is computed above; bracketed pastes take the paste
+      // branch, which forwards the stripped payload too.)
       if (
-        bashMode &&
-        this.optionsRef.isShellRunning() &&
-        (this.optionsRef.forwardWhileRunning?.() ?? false) &&
-        this.optionsRef.onForwardInput != null &&
+        forwardActive &&
         !isKeyRelease(data) &&
         (isPrintableInput(data) || data === "\r" || data === "\n" || data === "\x04")
       ) {
-        this.optionsRef.onForwardInput(data);
+        this.optionsRef.onForwardInput?.(data);
         return;
       }
 

package/bash-mode/pty-session.ts

@@ -22,6 +22,38 @@ import { basename, join } from "node:path";
 import { randomBytes } from "node:crypto";
 import { spawn, spawnSync, type ChildProcessWithoutNullStreams } from "node:child_process";
 
+const MAX_PENDING_LINE_BYTES = 64 * 1024;
+const MAX_ESCAPE_TAIL_CHARS = 4096;
+const TRUNCATED_LINE_NOTICE = "[wishcraft] output line truncated; keeping tail";
+
+/**
+ * Restricts a string to its trailing UTF-8 bytes without splitting a multibyte character.
+ *
+ * @param value - The string to restrict
+ * @param maxBytes - The maximum number of UTF-8 bytes to retain
+ * @returns The UTF-8-safe trailing portion of `value`
+ */
+function utf8Tail(value: string, maxBytes: number): string {
+  if (maxBytes <= 0) return "";
+  const bytes = Buffer.from(value, "utf8");
+  if (bytes.length <= maxBytes) return value;
+  let start = bytes.length - maxBytes;
+  while (start < bytes.length && (bytes[start]! & 0xc0) === 0x80) start += 1;
+  return bytes.subarray(start).toString("utf8");
+}
+
+/**
+ * Limits a partial terminal escape sequence to the configured character bound while preserving its introducer.
+ *
+ * @param value - The partial escape sequence to limit
+ * @returns The original value or a bounded value with its escape introducer preserved
+ */
+function boundedEscapeTail(value: string): string {
+  if (value.length <= MAX_ESCAPE_TAIL_CHARS) return value;
+  const prefixLength = value.startsWith("\x1b") && value.length > 1 ? 2 : 1;
+  return value.slice(0, prefixLength) + value.slice(-(MAX_ESCAPE_TAIL_CHARS - prefixLength));
+}
+
 /**
  * Fresh per-command completion delimiter. The wrapper prints it after the
  * sourced script ends; because it is unpredictable, a command cannot forge
@@ -121,6 +153,8 @@ interface RunningCommand {
   escapeTail: string;
   /** Wrapper result observed on stdout; publication waits for child close. */
   pendingResult: PtyRunResult | null;
+  /** Emit at most one notice when a single output line exceeds the pending cap. */
+  lineTruncated: boolean;
   resolve: (result: PtyRunResult) => void;
   settled: boolean;
 }
@@ -182,6 +216,7 @@ export class PtyShellSession {
         buffer: "",
         escapeTail: "",
         pendingResult: null,
+        lineTruncated: false,
         resolve: (result) => {
           if (running.settled) return;
           running.settled = true;
@@ -308,8 +343,9 @@ export class PtyShellSession {
     let work = merged;
     const partial = /(?:\x1b(?:\[[0-9;?]*[ -/]*|\][^\x07\x1b]*|[P^_][^\x07\x1b]*))$|\x1b$/.exec(work);
     if (partial) {
-      running.escapeTail = partial[0];
-      work = work.slice(0, work.length - running.escapeTail.length);
+      const rawTail = partial[0];
+      running.escapeTail = boundedEscapeTail(rawTail);
+      work = work.slice(0, work.length - rawTail.length);
     }
 
     const color = this.color && this.state.mode === "pty";
@@ -317,7 +353,13 @@ export class PtyShellSession {
 
     running.buffer += filtered;
     const parts = running.buffer.split("\n");
-    running.buffer = parts.pop() ?? "";
+    const remainder = parts.pop() ?? "";
+    const boundedRemainder = utf8Tail(remainder, MAX_PENDING_LINE_BYTES);
+    if (boundedRemainder !== remainder && !running.lineTruncated) {
+      running.lineTruncated = true;
+      this.onOutput(TRUNCATED_LINE_NOTICE);
+    }
+    running.buffer = boundedRemainder;
 
     for (const rawLine of parts) {
       const line = rawLine.replace(/\r$/, "");

package/bash-mode/transcript.ts

@@ -4,6 +4,29 @@ function byteLength(value: string): number {
   return Buffer.byteLength(value, "utf8");
 }
 
+/**
+ * Extracts the end of a string within a UTF-8 byte limit.
+ *
+ * @param value - The source string
+ * @param maxBytes - The maximum number of UTF-8 bytes to include
+ * @returns The UTF-8-safe tail of `value`
+ */
+function utf8Tail(value: string, maxBytes: number): string {
+  if (maxBytes <= 0) return "";
+  const bytes = Buffer.from(value, "utf8");
+  if (bytes.length <= maxBytes) return value;
+
+  let start = bytes.length - maxBytes;
+  while (start < bytes.length && (bytes[start]! & 0xc0) === 0x80) start += 1;
+  return bytes.subarray(start).toString("utf8");
+}
+
+/**
+ * Normalizes lines by removing carriage returns and splitting embedded newline characters.
+ *
+ * @param lines - The lines to normalize
+ * @returns The normalized lines
+ */
 function compactLines(lines: string[]): string[] {
   const normalized: string[] = [];
   for (const line of lines) {
@@ -119,8 +142,50 @@ export class BashTranscriptStore {
       this.commandIndex.delete(removed.id);
       this.totalLines = Math.max(0, this.totalLines - removed.output.length);
       this.totalBytes = Math.max(0, this.totalBytes - removed.outputBytes);
-      this.truncatedCommands += 1;
-      removed.truncated = true;
+      this.markTruncated(removed);
+    }
+
+    // A single active command used to bypass both global limits because there
+    // was no older command to evict. Trim that command from the head instead:
+    // bash mode is a tail-oriented live view, so the newest output is the
+    // useful part and memory remains bounded even for multi-megabyte logs.
+    const oldest = this.commands[0];
+    if (!oldest) return;
+
+    while (oldest.output.length > 0 && this.totalLines > this.settings.transcriptMaxLines) {
+      this.dropOldestLine(oldest);
+    }
+    while (oldest.output.length > 1 && this.totalBytes > this.settings.transcriptMaxBytes) {
+      this.dropOldestLine(oldest);
     }
+
+    if (oldest.output.length === 1 && this.totalBytes > this.settings.transcriptMaxBytes) {
+      const previous = oldest.output[0]!;
+      const previousBytes = byteLength(previous) + 1;
+      const bytesOutsideLine = Math.max(0, this.totalBytes - previousBytes);
+      const lineBudget = Math.max(0, this.settings.transcriptMaxBytes - bytesOutsideLine - 1);
+      const tail = utf8Tail(previous, lineBudget);
+      const tailBytes = byteLength(tail) + 1;
+      oldest.output[0] = tail;
+      oldest.outputBytes = Math.max(0, oldest.outputBytes - previousBytes + tailBytes);
+      this.totalBytes = Math.max(0, this.totalBytes - previousBytes + tailBytes);
+      this.markTruncated(oldest);
+    }
+  }
+
+  private dropOldestLine(command: BashCommandRecord): void {
+    const removed = command.output.shift();
+    if (removed === undefined) return;
+    const removedBytes = byteLength(removed) + 1;
+    command.outputBytes = Math.max(0, command.outputBytes - removedBytes);
+    this.totalLines = Math.max(0, this.totalLines - 1);
+    this.totalBytes = Math.max(0, this.totalBytes - removedBytes);
+    this.markTruncated(command);
+  }
+
+  private markTruncated(command: BashCommandRecord): void {
+    if (command.truncated) return;
+    command.truncated = true;
+    this.truncatedCommands += 1;
   }
 }

package/docs/bash-mode.md

@@ -24,6 +24,8 @@ The managed shell is persistent for the current pi session. Command output appea
 
 Commands run under a real PTY via `script(1)` (no native dependency), so programs that read stdin work: printable input typed while a command runs is forwarded to the process, and `ctrl+c` interrupts it. SGR color survives into the transcript when the terminal supports it; `NO_COLOR` renders plain text. When `script(1)` is missing, each command degrades to plain pipe execution with a one-time warning (no color, no interactive stdin).
 
+Privacy: forwarded keystrokes echo back through the PTY into the transcript (issue #71), so typing into a password-style prompt persists it in the transcript store. The first forward per run raises an info notice; avoid secrets at interactive prompts or clear the transcript afterwards. Pasted text while a command runs goes to the child stdin too (issue #72) — it never queues silently in the editor.
+
 ## Shell ghost suggestions
 
 Bash mode is ghost-first. Successful per-project shell history is the primary source, while deterministic path and git continuations can still extend an existing command. Shell-native completion probes are disabled so `!command` predictions never spawn interactive shell completion subprocesses.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@groeponline/pi-wishcraft",
-  "version": "1.4.16",
+  "version": "1.4.17",
   "description": "Operator cockpit for Pi: live powerline status, searchable skills, idea queue, sticky Bash, hooks, policy controls, and session UX.",
   "type": "module",
   "files": [

package/src/config/segment-options.ts

@@ -2,132 +2,144 @@ import { normalizeCostCurrency } from "../usage/rates.ts";
 import { isRecord } from "./primitives.ts";
 import type { StatusLineSegmentOptions } from "./types.ts";
 
+/**
+ * Normalizes raw segment configuration into supported status-line segment options.
+ *
+ * Invalid values are ignored, numeric limits are normalized, string values are trimmed,
+ * and non-empty template overrides are preserved for supported option groups.
+ *
+ * @param raw - Raw segment configuration to normalize
+ * @returns The validated and normalized segment options
+ */
 export function normalizeSegmentOptions(
   raw: Record<string, unknown>,
 ): StatusLineSegmentOptions {
   const options: StatusLineSegmentOptions = {};
 
   if (isRecord(raw.model)) {
-    options.model = {
-      ...(typeof raw.model.showThinkingLevel === "boolean"
-        ? { showThinkingLevel: raw.model.showThinkingLevel }
-        : {}),
-      ...(raw.model.display === "name" || raw.model.display === "qualified"
-        ? { display: raw.model.display }
-        : {}),
-    };
+    const model: NonNullable<StatusLineSegmentOptions["model"]> = {};
+    if (typeof raw.model.showThinkingLevel === "boolean") {
+      model.showThinkingLevel = raw.model.showThinkingLevel;
+    }
+    if (raw.model.display === "name" || raw.model.display === "qualified") {
+      model.display = raw.model.display;
+    }
+    options.model = model;
   }
 
   if (isRecord(raw.path)) {
-    options.path = {
-      ...(raw.path.mode === "basename" ||
+    const path: NonNullable<StatusLineSegmentOptions["path"]> = {};
+    if (
+      raw.path.mode === "basename" ||
       raw.path.mode === "abbreviated" ||
       raw.path.mode === "full"
-        ? { mode: raw.path.mode }
-        : {}),
-      ...(typeof raw.path.maxLength === "number" &&
+    ) {
+      path.mode = raw.path.mode;
+    }
+    if (
+      typeof raw.path.maxLength === "number" &&
       Number.isFinite(raw.path.maxLength) &&
       raw.path.maxLength > 0
-        ? { maxLength: Math.floor(raw.path.maxLength) }
-        : {}),
-    };
+    ) {
+      path.maxLength = Math.floor(raw.path.maxLength);
+    }
+    options.path = path;
   }
 
   if (isRecord(raw.git)) {
-    options.git = {
-      ...(typeof raw.git.showBranch === "boolean"
-        ? { showBranch: raw.git.showBranch }
-        : {}),
-      ...(typeof raw.git.showStaged === "boolean"
-        ? { showStaged: raw.git.showStaged }
-        : {}),
-      ...(typeof raw.git.showUnstaged === "boolean"
-        ? { showUnstaged: raw.git.showUnstaged }
-        : {}),
-      ...(typeof raw.git.showUntracked === "boolean"
-        ? { showUntracked: raw.git.showUntracked }
-        : {}),
-      ...(raw.git.polling === "full" ||
+    const git: NonNullable<StatusLineSegmentOptions["git"]> = {};
+    if (typeof raw.git.showBranch === "boolean") git.showBranch = raw.git.showBranch;
+    if (typeof raw.git.showStaged === "boolean") git.showStaged = raw.git.showStaged;
+    if (typeof raw.git.showUnstaged === "boolean") {
+      git.showUnstaged = raw.git.showUnstaged;
+    }
+    if (typeof raw.git.showUntracked === "boolean") {
+      git.showUntracked = raw.git.showUntracked;
+    }
+    if (
+      raw.git.polling === "full" ||
       raw.git.polling === "branch" ||
       raw.git.polling === "off"
-        ? { polling: raw.git.polling }
-        : {}),
-      ...(typeof raw.git.hostIcon === "boolean"
-        ? { hostIcon: raw.git.hostIcon }
-        : {}),
-      ...(typeof raw.git.showAheadBehind === "boolean"
-        ? { showAheadBehind: raw.git.showAheadBehind }
-        : {}),
-      ...(typeof raw.git.showCommit === "boolean"
-        ? { showCommit: raw.git.showCommit }
-        : {}),
-      ...(typeof raw.git.maxCommitSubjectLength === "number" &&
+    ) {
+      git.polling = raw.git.polling;
+    }
+    if (typeof raw.git.hostIcon === "boolean") git.hostIcon = raw.git.hostIcon;
+    if (typeof raw.git.showAheadBehind === "boolean") {
+      git.showAheadBehind = raw.git.showAheadBehind;
+    }
+    if (typeof raw.git.showCommit === "boolean") git.showCommit = raw.git.showCommit;
+    if (
+      typeof raw.git.maxCommitSubjectLength === "number" &&
       Number.isFinite(raw.git.maxCommitSubjectLength) &&
       raw.git.maxCommitSubjectLength > 0
-        ? { maxCommitSubjectLength: Math.floor(raw.git.maxCommitSubjectLength) }
-        : {}),
-    };
+    ) {
+      git.maxCommitSubjectLength = Math.floor(raw.git.maxCommitSubjectLength);
+    }
+    options.git = git;
   }
 
   if (isRecord(raw.time)) {
-    options.time = {
-      ...(raw.time.format === "12h" || raw.time.format === "24h"
-        ? { format: raw.time.format }
-        : {}),
-      ...(typeof raw.time.showSeconds === "boolean"
-        ? { showSeconds: raw.time.showSeconds }
-        : {}),
-    };
+    const time: NonNullable<StatusLineSegmentOptions["time"]> = {};
+    if (raw.time.format === "12h" || raw.time.format === "24h") {
+      time.format = raw.time.format;
+    }
+    if (typeof raw.time.showSeconds === "boolean") {
+      time.showSeconds = raw.time.showSeconds;
+    }
+    options.time = time;
   }
 
   if (isRecord(raw.cost)) {
     const currency = normalizeCostCurrency(raw.cost.currency);
-    options.cost = {
-      ...(raw.cost.subscriptionDisplay === "subscription" ||
+    const cost: NonNullable<StatusLineSegmentOptions["cost"]> = {};
+    if (
+      raw.cost.subscriptionDisplay === "subscription" ||
       raw.cost.subscriptionDisplay === "reported-cost" ||
       raw.cost.subscriptionDisplay === "both"
-        ? { subscriptionDisplay: raw.cost.subscriptionDisplay }
-        : {}),
-      ...(currency ? { currency } : {}),
-    };
+    ) {
+      cost.subscriptionDisplay = raw.cost.subscriptionDisplay;
+    }
+    if (currency) cost.currency = currency;
+    options.cost = cost;
   }
 
   if (isRecord(raw.context)) {
-    options.context = {
-      ...(raw.context.format === "full" || raw.context.format === "percent"
-        ? { format: raw.context.format }
-        : {}),
-    };
+    const context: NonNullable<StatusLineSegmentOptions["context"]> = {};
+    if (raw.context.format === "full" || raw.context.format === "percent") {
+      context.format = raw.context.format;
+    }
+    options.context = context;
   }
 
   if (isRecord(raw.cache_read)) {
-    options.cache_read = {
-      ...(raw.cache_read.format === "tokens" ||
+    const cacheRead: NonNullable<StatusLineSegmentOptions["cache_read"]> = {};
+    if (
+      raw.cache_read.format === "tokens" ||
       raw.cache_read.format === "percent" ||
       raw.cache_read.format === "both"
-        ? { format: raw.cache_read.format }
-        : {}),
-    };
+    ) {
+      cacheRead.format = raw.cache_read.format;
+    }
+    options.cache_read = cacheRead;
   }
 
   if (isRecord(raw.openPorts)) {
-    options.openPorts = {
-      ...(typeof raw.openPorts.includeUdp === "boolean"
-        ? { includeUdp: raw.openPorts.includeUdp }
-        : {}),
-      ...(typeof raw.openPorts.host === "string" && raw.openPorts.host.trim()
-        ? { host: raw.openPorts.host.trim() }
-        : {}),
-    };
+    const openPorts: NonNullable<StatusLineSegmentOptions["openPorts"]> = {};
+    if (typeof raw.openPorts.includeUdp === "boolean") {
+      openPorts.includeUdp = raw.openPorts.includeUdp;
+    }
+    if (typeof raw.openPorts.host === "string" && raw.openPorts.host.trim()) {
+      openPorts.host = raw.openPorts.host.trim();
+    }
+    options.openPorts = openPorts;
   }
 
   if (isRecord(raw.tps)) {
-    options.tps = {
-      ...(typeof raw.tps.windowMs === "number" &&
-      Number.isFinite(raw.tps.windowMs)
-        ? { windowMs: Math.min(5000, Math.max(500, Math.floor(raw.tps.windowMs))) }
-        : {}),
-    };
+    const tps: NonNullable<StatusLineSegmentOptions["tps"]> = {};
+    if (typeof raw.tps.windowMs === "number" && Number.isFinite(raw.tps.windowMs)) {
+      tps.windowMs = Math.min(5000, Math.max(500, Math.floor(raw.tps.windowMs)));
+    }
+    options.tps = tps;
   }
 
   // Generic `template` override for every segment option group:

package/src/config/structural-preset-data.ts

@@ -0,0 +1,69 @@
+/**
+ * structural-preset-data.ts
+ * ---------------------------------------------------------------------------
+ * Shared helpers and chrome/deck/welcome constants for the structural presets.
+ * The preset definitions live in structural-preset-table.ts; the public API
+ * (getStructuralPreset, etc.) stays in structural-presets.ts.
+ * ---------------------------------------------------------------------------
+ */
+
+import type { ChromeSpec, DeckSpec, MotionRef, WelcomeSpec, WishcraftTokens } from "./types.ts";
+import type { MotionEvent } from "../motion/types.ts";
+
+export function tokens(partial: Partial<WishcraftTokens>): Partial<WishcraftTokens> {
+  return partial;
+}
+
+export function motion(
+  signature: MotionRef,
+  overrides?: Partial<Record<MotionEvent, MotionRef>>,
+): Partial<Record<MotionEvent, MotionRef>> {
+  const base: Partial<Record<MotionEvent, MotionRef>> = {
+    idle: "wisp",
+    thinking: signature,
+    streaming: signature,
+    "tool.start": signature,
+    "tool.end": "rune-bloom",
+    "idea.capture": "rune-bloom",
+    "skill.insert": "rune-bloom",
+    "policy.deny": "rune-bloom",
+    repair: signature,
+    compact: "bar",
+    success: "rune-bloom",
+    warning: "rune-bloom",
+    error: "rune-bloom",
+  };
+  return { ...base, ...overrides };
+}
+
+export const ROUNDED_CHROME: ChromeSpec = {
+  frame: "rounded",
+  corners: { tl: "╭", tr: "╮", bl: "╰", br: "╯" },
+  dividers: { horizontal: "─", vertical: "│", cross: "┼" },
+  density: "medium",
+};
+
+export const MINIMAL_CHROME: ChromeSpec = {
+  frame: "minimal",
+  corners: { tl: " ", tr: " ", bl: " ", br: " " },
+  dividers: { horizontal: "─", vertical: " ", cross: " " },
+  density: "spacious",
+};
+
+export const BORDERLESS_CHROME: ChromeSpec = {
+  frame: "borderless",
+  corners: { tl: "", tr: "", bl: "", br: "" },
+  dividers: { horizontal: "─", vertical: " ", cross: " " },
+  density: "spacious",
+};
+
+export const DEFAULT_DECK: DeckSpec = {
+  navigation: "tabs",
+  panelStyle: "framed",
+  activityStyle: "pulse",
+};
+
+export const DEFAULT_WELCOME: WelcomeSpec = {
+  lantern: true,
+  ambient: true,
+};