@gonrocca/zero-pi 0.1.64 → 0.1.66

package/README.md

@@ -113,7 +113,10 @@ into `/forge` for you.
 | **Run memory** | Every run recalls and saves traces to Cortex, so runs learn from each other. |
 | **Provider guard** | Warns when the `anthropic` provider runs on a metered API key instead of your subscription. |
 | **Startup banner** | The sunset ANSI-Shadow `ZERO` wordmark, drawn once at pi startup — `ZERO_HEADER=off` to disable. |
-| **Working-phrase ticker** | Swaps pi's `Working...` for a context-aware Spanish phrase + spinner. |
+| **ZERO HUD** | OMP-inspired segmented footer for SDD work: phase, model, tokens, cache, cost, diff, context %, and branch. Switch presets with `/zero-hud compact\|minimal\|full\|ascii\|off` or `ZERO_HUD_PRESET`. |
+| **Pretty input box** | OMP-style prompt chrome with rounded corners, side borders, ZERO chips, and compact keyboard hints. |
+| **Pretty code fences** | Markdown code blocks render as bordered panels with language badges instead of raw ```txt / ```json fence lines. |
+| **Working-phrase ticker** | Swaps pi's static `Working...` / `Procesando...` for a large pool of context-aware Spanish/ZERO/SDD phrases + spinner. |
 | **Conversation resume** | Writes `.pi/zero-resume.md` on exit — the restore command + a conversation tail. |
 | **Windows tree-kill** | Aborting a turn kills the whole process tree — no orphaned `claude`. |
 | **SDD routing skill** | Natural-language requests that say "hacelo con sdd" route into `/forge` without remembering the slash command. |
@@ -131,6 +134,7 @@ into `/forge` for you.
 | `/zero-archive <slug>` | Merge an approved run into `.sdd/specs/`, move it to `.sdd/archive/YYYY-MM-DD-<slug>/`, and persist `archivePath`. |
 | `/zero-validate <slug>` | Validate proposal/spec/design/tasks artifacts, including task schema and per-domain specs. |
 | `/zero-status` | Show each `.sdd/` run's artifact, sync, latest-verdict, and GitHub-link status. |
+| `/zero-hud [compact\|minimal\|full\|ascii\|off\|on\|preview]` | Preview or switch the segmented ZERO footer for this pi session. Default preset: `compact`. |
 | `/zero-cost [<slug>]` | Report tokens (in/out/cache), USD cost, duration, and tool-count per SDD phase for a run — reads native pi session metas and project-local `.pi-subagents/artifacts`; `<slug>` for a specific run, no argument for the most recent. |
 | `/zero-checkpoint [<slug>] [--json]` | Save `diff.patch`, `status.txt`, `head.txt`, `meta.json`, and a review-before-running `restore.sh` under `.sdd/<slug>/checkpoints/<id>/`. |
 | `/zero-branch <slug>` | Create/reuse the configured SDD Git branch and persist `branch`/`baseBranch`. |

package/extensions/working-phrases.ts

@@ -40,15 +40,39 @@ const THINKING_PLAYFUL = [
   "Maquinando",
   "Rumiando",
   "Pensando",
-  "Cocinando",
-  "Tramando",
-  "Conjurando",
-  "Cavilando",
+  "Cocinando una idea",
+  "Tramando el próximo paso",
+  "Conjurando contexto",
+  "Cavilando fino",
   "Hilando ideas",
-  "Procesando",
+  "Procesando señales",
   "Razonando",
   "Atando cabos",
-  "Calibrando",
+  "Calibrando criterio",
+  "Afilando el lápiz",
+  "Leyendo entre líneas",
+  "Buscando el camino corto",
+  "Separando ruido de señal",
+  "Ordenando el quilombo",
+  "Mirando el diff mental",
+  "Midiendo impacto",
+  "Puliendo la respuesta",
+  "Armando la jugada",
+  "Pensando como reviewer",
+  "Evitando overengineering",
+  "Cuidando tus tokens",
+  "Chequeando supuestos",
+  "Bajando a tierra",
+  "Buscando el bug escondido",
+  "Haciendo magia responsable",
+  "Tirando del hilo",
+  "Cruzando evidencia",
+  "Afinando el plan",
+  "Sacando filo",
+  "Cargando mate cognitivo",
+  "No rompiendo producción",
+  "Haciendo que compile en la cabeza",
+  "Respirando antes de tocar código",
 ];
 
 /** Thinking verbs biased toward SDD work — used once an SDD run is detected. */
@@ -59,6 +83,21 @@ const THINKING_SDD = [
   "Revisando supuestos",
   "Ordenando las tareas",
   "Cuadrando el spec",
+  "Alineando requisitos",
+  "Buscando criterios de éxito",
+  "Separando explore de build",
+  "Guardando el contexto útil",
+  "Preparando el veredicto",
+  "Pensando tests primero",
+  "Revisando riesgos",
+  "Midiendo alcance",
+  "Evitando scope creep",
+  "Diseñando el camino mínimo",
+  "Armando evidencia TDD",
+  "Verificando invariantes",
+  "Preguntando lo justo",
+  "Cerrando ambigüedades",
+  "Forjando el spec",
   "Maquinando",
   "Razonando",
 ];
@@ -79,9 +118,15 @@ const TOOL_RULES: Array<[RegExp, string]> = [
   [/(multi.?edit|str.?replace|edit|patch|apply)/i, "Aplicando cambios"],
   [/(write|create)/i, "Escribiendo archivos"],
   [/(bash|shell|exec|run|terminal|cmd)/i, "Ejecutando comandos"],
+  [/(test|vitest|jest|mocha|node:test|coverage)/i, "Corriendo pruebas"],
+  [/(npm|pnpm|bun|yarn|publish|pack)/i, "Preparando paquete"],
+  [/(git|commit|push|branch|diff|status)/i, "Hablando con git"],
   [/(grep|search|ripgrep|^rg)/i, "Buscando en el código"],
   [/(glob|find|^ls$|list|tree)/i, "Rastreando archivos"],
   [/(web|fetch|http|url|browse|curl)/i, "Navegando la web"],
+  [/(browser|click|type|screenshot|tab)/i, "Moviendo el navegador"],
+  [/(cortex|memoria|memory|recall)/i, "Consultando memoria"],
+  [/(image|screenshot|vision)/i, "Mirando la imagen"],
   [/(subagent|custom-agent|^task$|agent)/i, "Coordinando sub-agentes"],
   [/(todo|plan)/i, "Ordenando el plan"],
 ];

package/extensions/zero-hud.ts

@@ -0,0 +1,453 @@
+// zero-pi — ZERO HUD statusline.
+//
+// A segmented footer inspired by omp's status-line presets, adapted to ZERO SDD:
+// phase-aware, cost-aware, compact by default, and fully defensive. This
+// replaces the older one-piece `zero-statusline` package extension while keeping
+// that file around for backwards-compatible imports/tests.
+//
+// Runtime controls:
+//   ZERO_HUD_PRESET=compact|minimal|full|ascii|off
+//   /zero-hud compact|minimal|full|ascii|off|on|preview
+
+import { exec } from "node:child_process";
+import { promisify } from "node:util";
+
+const execAsync = promisify(exec);
+
+type RGB = [number, number, number];
+type HudPreset = "minimal" | "compact" | "full" | "ascii" | "off";
+type Phase = "clarify" | "explore" | "plan" | "analyze" | "build" | "veredicto" | "forge";
+
+const CORAL: RGB = [255, 124, 92];
+const GOLD: RGB = [255, 214, 130];
+const PEACH: RGB = [255, 168, 99];
+const ROSE: RGB = [255, 106, 122];
+const ORCHID: RGB = [176, 106, 179];
+const MINT: RGB = [79, 221, 171];
+const AMBER: RGB = [238, 190, 92];
+const SKY: RGB = [109, 184, 230];
+const STEEL: RGB = [176, 152, 142];
+const DIM: RGB = [120, 104, 98];
+
+const ANSI_RE = /\x1b\[[0-9;]*m/g;
+const STATUS_ID = "zero-hud";
+const BRAND = "ZERO";
+
+function fg([r, g, b]: RGB, text: string): string {
+  return `\x1b[38;2;${r};${g};${b}m${text}\x1b[0m`;
+}
+
+function plain(text: string): string {
+  return text.replace(ANSI_RE, "");
+}
+
+function dim(text: string): string {
+  return fg(DIM, text);
+}
+
+function phaseColor(phase: Phase | undefined): RGB {
+  switch (phase) {
+    case "clarify": return GOLD;
+    case "explore": return SKY;
+    case "plan": return PEACH;
+    case "analyze": return ORCHID;
+    case "build": return CORAL;
+    case "veredicto": return MINT;
+    case "forge": return GOLD;
+    default: return DIM;
+  }
+}
+
+export function normalizePreset(value: string | undefined): HudPreset | null {
+  const raw = (value ?? "").trim().toLowerCase();
+  if (raw === "minimal" || raw === "compact" || raw === "full" || raw === "ascii" || raw === "off") return raw;
+  if (raw === "on") return "compact";
+  return raw === "" ? null : null;
+}
+
+export function formatTokenCount(n: number): string {
+  if (!Number.isFinite(n) || n < 0) return "0";
+  if (n < 1000) return `${Math.floor(n)}`;
+  if (n < 1_000_000) return `${(n / 1000).toFixed(1)}K`;
+  return `${(n / 1_000_000).toFixed(1)}M`;
+}
+
+export function formatUsd(n: number | undefined): string | undefined {
+  if (typeof n !== "number" || !Number.isFinite(n) || n <= 0) return undefined;
+  if (n < 0.01) return `$${n.toFixed(4)}`;
+  if (n < 1) return `$${n.toFixed(3)}`;
+  return `$${n.toFixed(2)}`;
+}
+
+export function ctxColor(percent: number): RGB {
+  if (!Number.isFinite(percent) || percent < 50) return MINT;
+  if (percent < 80) return AMBER;
+  return ROSE;
+}
+
+export function shortModel(id: string | undefined): string | undefined {
+  if (!id) return undefined;
+  const slash = id.lastIndexOf("/");
+  const bare = slash >= 0 ? id.slice(slash + 1) : id;
+  return bare || undefined;
+}
+
+function shortBranch(value: string | undefined): string | undefined {
+  if (!value) return undefined;
+  return value.length <= 24 ? value : `…${value.slice(-23)}`;
+}
+
+export interface SessionUsage {
+  input: number;
+  output: number;
+  cacheRead: number;
+  cacheWrite: number;
+  costUsd: number;
+}
+
+interface PiSessionEntry {
+  type?: string;
+  message?: {
+    role?: string;
+    usage?: {
+      input?: number;
+      output?: number;
+      cacheRead?: number;
+      cacheWrite?: number;
+      cost?: number | { total?: number; input?: number; output?: number; cacheRead?: number; cacheWrite?: number };
+    };
+  };
+}
+interface PiSessionManager {
+  getEntries?(): PiSessionEntry[];
+}
+
+function positive(n: unknown): number {
+  return typeof n === "number" && Number.isFinite(n) && n > 0 ? n : 0;
+}
+
+function usageCost(usage: PiSessionEntry["message"] extends infer M ? M extends { usage?: infer U } ? U : never : never): number {
+  if (!usage || typeof usage !== "object") return 0;
+  const cost = (usage as { cost?: unknown }).cost;
+  if (typeof cost === "number") return positive(cost);
+  if (cost && typeof cost === "object") {
+    const c = cost as { total?: unknown; input?: unknown; output?: unknown; cacheRead?: unknown; cacheWrite?: unknown };
+    return positive(c.total) || positive(c.input) + positive(c.output) + positive(c.cacheRead) + positive(c.cacheWrite);
+  }
+  return 0;
+}
+
+export function computeSessionUsage(sessionManager: PiSessionManager | undefined): SessionUsage {
+  const totals: SessionUsage = { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, costUsd: 0 };
+  if (!sessionManager || typeof sessionManager.getEntries !== "function") return totals;
+  try {
+    for (const entry of sessionManager.getEntries()) {
+      if (entry?.type !== "message") continue;
+      if (entry.message?.role !== "assistant") continue;
+      const u = entry.message.usage;
+      if (!u) continue;
+      totals.input += positive(u.input);
+      totals.output += positive(u.output);
+      totals.cacheRead += positive(u.cacheRead);
+      totals.cacheWrite += positive(u.cacheWrite);
+      totals.costUsd += usageCost(u);
+    }
+  } catch {
+    // Return what we collected so far.
+  }
+  totals.costUsd = Math.round((totals.costUsd + Number.EPSILON) * 1_000_000) / 1_000_000;
+  return totals;
+}
+
+const SDD_AGENT_TO_PHASE: Record<string, Phase> = {
+  "zero-clarify": "clarify",
+  "zero-explore": "explore",
+  "zero-plan": "plan",
+  "zero-analyze": "analyze",
+  "zero-build": "build",
+  "zero-veredicto": "veredicto",
+};
+
+export function phaseFromSubagentArgs(args: unknown): Phase | undefined {
+  const names = new Set<string>();
+  const collect = (value: unknown): void => {
+    if (typeof value === "string" && value.trim()) names.add(value.trim());
+  };
+  const walk = (value: unknown): void => {
+    if (!value || typeof value !== "object") return;
+    const record = value as Record<string, unknown>;
+    collect(record.agent);
+    for (const key of ["chain", "tasks", "parallel"] as const) {
+      const list = record[key];
+      if (Array.isArray(list)) for (const item of list) walk(item);
+    }
+  };
+  walk(args);
+  for (const name of names) {
+    const key = name.toLowerCase().split(".").pop() ?? name.toLowerCase();
+    if (SDD_AGENT_TO_PHASE[key]) return SDD_AGENT_TO_PHASE[key];
+  }
+  return undefined;
+}
+
+export function phaseFromInput(text: string): Phase | undefined {
+  return /\/forge\b|\bforge\b|zero[\s-]?sdd|\bsdd\b/i.test(text ?? "") ? "forge" : undefined;
+}
+
+export interface HudParts {
+  phase?: Phase;
+  model?: string;
+  tokensIn?: number;
+  tokensOut?: number;
+  cacheRead?: number;
+  costUsd?: number;
+  diffAdded?: number;
+  diffRemoved?: number;
+  ctxPercent?: number;
+  branch?: string;
+  preset?: HudPreset;
+}
+
+function separator(preset: HudPreset): string {
+  if (preset === "ascii") return dim(" | ");
+  if (preset === "minimal") return dim(" / ");
+  return dim(" ▸ ");
+}
+
+function segment(label: string, value: string, color: RGB, preset: HudPreset): string {
+  if (preset === "ascii") return `${label}:${plain(value)}`;
+  return `${dim(label)} ${fg(color, value)}`;
+}
+
+export function composeHud(parts: HudParts): string {
+  const preset = parts.preset ?? "compact";
+  if (preset === "off") return "";
+
+  const out: string[] = [];
+  const sep = separator(preset);
+
+  if (preset !== "minimal") {
+    out.push(preset === "ascii" ? BRAND : fg(GOLD, BRAND));
+  }
+
+  if (parts.phase) {
+    const value = preset === "ascii" ? parts.phase : `◆ ${parts.phase}`;
+    out.push(segment("phase", value, phaseColor(parts.phase), preset));
+  }
+
+  if (parts.model && preset !== "minimal") {
+    out.push(fg(CORAL, parts.model));
+  }
+
+  if (parts.tokensIn != null || parts.tokensOut != null) {
+    const tokenText = `↑${formatTokenCount(parts.tokensIn ?? 0)} ↓${formatTokenCount(parts.tokensOut ?? 0)}`;
+    out.push(segment("tok", tokenText, PEACH, preset));
+  }
+
+  if (preset === "full" && parts.cacheRead && parts.cacheRead > 0) {
+    out.push(segment("cache", `↺${formatTokenCount(parts.cacheRead)}`, SKY, preset));
+  }
+
+  const cost = formatUsd(parts.costUsd);
+  if (cost && preset !== "minimal") {
+    out.push(segment("cost", cost, ORCHID, preset));
+  }
+
+  if (parts.diffAdded != null || parts.diffRemoved != null) {
+    const diff = `+${parts.diffAdded ?? 0}/-${parts.diffRemoved ?? 0}`;
+    out.push(segment("diff", diff, (parts.diffAdded ?? 0) || (parts.diffRemoved ?? 0) ? MINT : DIM, preset));
+  }
+
+  if (parts.ctxPercent != null && Number.isFinite(parts.ctxPercent)) {
+    out.push(segment("ctx", `${Math.round(parts.ctxPercent)}%`, ctxColor(parts.ctxPercent), preset));
+  }
+
+  const branch = shortBranch(parts.branch);
+  if (branch && preset !== "minimal") {
+    out.push(segment("git", branch, STEEL, preset));
+  }
+
+  return out.join(sep);
+}
+
+interface PiUI {
+  setStatus(id: string, text: string | undefined): void;
+  notify?(message: string, level?: "info" | "warning" | "error"): void;
+}
+interface PiModel {
+  id?: string;
+  name?: string;
+  contextWindow?: number;
+}
+interface PiCtx {
+  ui?: PiUI;
+  model?: PiModel;
+  cwd?: string;
+  sessionManager?: PiSessionManager;
+  getContextUsage?(): { tokens?: number } | null | undefined;
+}
+interface PiAPI {
+  on(event: string, handler: (event: unknown, ctx: PiCtx) => void): void;
+  registerCommand?(name: string, options: { description: string; handler: (args: string, ctx: PiCtx) => unknown }): void;
+}
+
+let branch: string | undefined;
+let added = 0;
+let removed = 0;
+let lastCtx: PiCtx | undefined;
+let gitInFlight = false;
+let preset: HudPreset = normalizePreset(process.env.ZERO_HUD_PRESET) ?? "compact";
+let activePhase: Phase | undefined;
+
+function resetSessionState(): void {
+  branch = undefined;
+  added = 0;
+  removed = 0;
+  activePhase = undefined;
+}
+
+async function readGit(cwdHint: string | undefined): Promise<void> {
+  const cwd = cwdHint || process.cwd();
+  if (!cwd || gitInFlight) return;
+  gitInFlight = true;
+  try {
+    try {
+      const { stdout } = await execAsync("git rev-parse --abbrev-ref HEAD", { cwd, timeout: 1500, windowsHide: true });
+      branch = stdout.trim() || undefined;
+    } catch {
+      branch = undefined;
+    }
+    try {
+      const { stdout } = await execAsync("git diff --shortstat", { cwd, timeout: 1500, windowsHide: true });
+      const ins = stdout.match(/(\d+)\s+insertions?\(\+\)/);
+      const del = stdout.match(/(\d+)\s+deletions?\(-\)/);
+      added = ins ? parseInt(ins[1], 10) : 0;
+      removed = del ? parseInt(del[1], 10) : 0;
+    } catch {
+      added = 0;
+      removed = 0;
+    }
+  } finally {
+    gitInFlight = false;
+  }
+}
+
+function render(ctx: PiCtx): void {
+  try {
+    if (!ctx?.ui || typeof ctx.ui.setStatus !== "function") return;
+    if (preset === "off") {
+      ctx.ui.setStatus(STATUS_ID, undefined);
+      return;
+    }
+    const window = ctx.model?.contextWindow && ctx.model.contextWindow > 0 ? ctx.model.contextWindow : 200_000;
+    const used = ctx.getContextUsage?.()?.tokens;
+    const ctxPercent = typeof used === "number" && used >= 0 ? Math.min(100, (used / window) * 100) : undefined;
+    const usage = computeSessionUsage(ctx.sessionManager);
+    const text = composeHud({
+      preset,
+      phase: activePhase,
+      model: shortModel(ctx.model?.id ?? ctx.model?.name),
+      tokensIn: usage.input,
+      tokensOut: usage.output,
+      cacheRead: usage.cacheRead,
+      costUsd: usage.costUsd,
+      diffAdded: added,
+      diffRemoved: removed,
+      ctxPercent,
+      branch,
+    });
+    ctx.ui.setStatus(STATUS_ID, text || undefined);
+  } catch {
+    // HUD failures must never break a pi session.
+  }
+}
+
+function preview(nextPreset: HudPreset): string {
+  return plain(composeHud({
+    preset: nextPreset,
+    phase: "build",
+    model: "claude-opus-4-7",
+    tokensIn: 128_400,
+    tokensOut: 8_120,
+    cacheRead: 512_000,
+    costUsd: 0.042,
+    diffAdded: 120,
+    diffRemoved: 8,
+    ctxPercent: 42,
+    branch: "sdd/zero-hud",
+  }));
+}
+
+export default function register(pi?: unknown): void {
+  try {
+    if (!pi || typeof (pi as PiAPI).on !== "function") return;
+    const api = pi as PiAPI;
+
+    api.registerCommand?.("zero-hud", {
+      description: "Preview or switch the ZERO HUD footer (minimal|compact|full|ascii|off|on|preview).",
+      handler: (args, ctx) => {
+        const raw = (args ?? "").trim().toLowerCase();
+        const next = raw === "preview" || raw === "" ? preset : normalizePreset(raw);
+        if (!next) {
+          ctx.ui?.notify?.("Uso: /zero-hud minimal|compact|full|ascii|off|on|preview", "warning");
+          return;
+        }
+        if (raw !== "preview" && raw !== "") preset = next;
+        render(ctx);
+        ctx.ui?.notify?.(`ZERO HUD ${raw === "preview" || raw === "" ? "preview" : "preset"}: ${next}\n${preview(next)}`, "info");
+      },
+    });
+
+    api.on("session_start", (_event, ctx) => {
+      lastCtx = ctx;
+      resetSessionState();
+      render(ctx);
+      void readGit(ctx?.cwd).then(() => render(ctx));
+    });
+
+    api.on("input", (event, ctx) => {
+      lastCtx = ctx;
+      const phase = phaseFromInput((event as { text?: string })?.text ?? "");
+      if (phase) activePhase = phase;
+      render(ctx);
+    });
+
+    api.on("model_select", (_event, ctx) => {
+      lastCtx = ctx;
+      render(ctx);
+    });
+
+    api.on("message_update", (_event, ctx) => {
+      lastCtx = ctx;
+      render(ctx);
+    });
+
+    api.on("tool_execution_start", (event, ctx) => {
+      lastCtx = ctx;
+      const e = event as { toolName?: string; args?: unknown };
+      const phase = /subagent|task/i.test(e.toolName ?? "") ? phaseFromSubagentArgs(e.args) : undefined;
+      if (phase) activePhase = phase;
+      render(ctx);
+    });
+
+    api.on("tool_execution_end", (_event, ctx) => {
+      lastCtx = ctx;
+      void readGit(ctx?.cwd).then(() => render(ctx));
+    });
+
+    api.on("agent_end", (_event, ctx) => {
+      lastCtx = ctx;
+      render(ctx);
+    });
+
+    api.on("session_shutdown", () => {
+      try {
+        lastCtx?.ui?.setStatus?.(STATUS_ID, undefined);
+      } catch {
+        // ignore
+      }
+    });
+  } catch {
+    // Registration itself must never break a pi session.
+  }
+}

package/extensions/zero-pretty-code-fences.ts

@@ -0,0 +1,76 @@
+import { Markdown, visibleWidth } from "@earendil-works/pi-tui";
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+
+type MarkdownInstance = {
+	theme: {
+		codeBlock: (text: string) => string;
+		codeBlockBorder: (text: string) => string;
+		codeBlockIndent?: string;
+		highlightCode?: (code: string, lang?: string) => string[];
+	};
+	renderToken: (token: { type?: string; text?: string; lang?: string }, width: number, nextTokenType?: string, styleContext?: unknown) => string[];
+};
+
+const PATCHED = Symbol.for("gon.pi.pretty-code-fences.patched");
+
+function displayLang(lang?: string): string {
+	const raw = (lang ?? "").trim().toLowerCase();
+	if (!raw || raw === "txt" || raw === "text" || raw === "plain") return "";
+	if (raw === "typescript") return "ts";
+	if (raw === "javascript") return "js";
+	if (raw === "shell" || raw === "bash") return "sh";
+	return raw;
+}
+
+function border(theme: MarkdownInstance["theme"], width: number, position: "top" | "bottom", lang = ""): string {
+	const maxWidth = Math.max(10, Math.min(width, 96));
+	if (position === "bottom") {
+		return theme.codeBlockBorder(`╰${"─".repeat(Math.max(1, maxWidth - 2))}╯`);
+	}
+
+	const label = lang ? ` ${lang} ` : "";
+	const prefix = `╭─${label}`;
+	const suffix = "╮";
+	const fill = "─".repeat(Math.max(1, maxWidth - visibleWidth(prefix) - visibleWidth(suffix)));
+	return theme.codeBlockBorder(`${prefix}${fill}${suffix}`);
+}
+
+function patchMarkdownRenderer(): void {
+	const proto = Markdown.prototype as unknown as MarkdownInstance & { [PATCHED]?: boolean };
+	if (proto[PATCHED]) return;
+	proto[PATCHED] = true;
+
+	const original = proto.renderToken;
+	proto.renderToken = function prettyRenderToken(token, width, nextTokenType, styleContext): string[] {
+		if (token?.type !== "code") {
+			return original.call(this, token, width, nextTokenType, styleContext);
+		}
+
+		const lang = displayLang(token.lang);
+		const lines: string[] = [];
+		const gutter = this.theme.codeBlockBorder("│ ");
+		lines.push(border(this.theme, width, "top", lang));
+
+		if (this.theme.highlightCode) {
+			const highlightedLines = this.theme.highlightCode(token.text ?? "", token.lang);
+			for (const hlLine of highlightedLines) {
+				lines.push(`${gutter}${hlLine}`);
+			}
+		} else {
+			const codeLines = (token.text ?? "").split("\n");
+			for (const codeLine of codeLines) {
+				lines.push(`${gutter}${this.theme.codeBlock(codeLine)}`);
+			}
+		}
+
+		lines.push(border(this.theme, width, "bottom"));
+		if (nextTokenType && nextTokenType !== "space") {
+			lines.push("");
+		}
+		return lines;
+	};
+}
+
+export default function (_pi: ExtensionAPI) {
+	patchMarkdownRenderer();
+}

package/extensions/zero-pretty-input-box.ts

@@ -0,0 +1,93 @@
+import { Editor, truncateToWidth, visibleWidth } from "@earendil-works/pi-tui";
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+
+const PATCHED = Symbol.for("gon.pi.pretty-input-box.patched");
+const ANSI_RE = /\x1b\[[0-9;]*m/g;
+
+function rgb(hex: string, text: string): string {
+	const clean = hex.replace(/^#/, "");
+	const r = Number.parseInt(clean.slice(0, 2), 16);
+	const g = Number.parseInt(clean.slice(2, 4), 16);
+	const b = Number.parseInt(clean.slice(4, 6), 16);
+	return `\x1b[38;2;${r};${g};${b}m${text}\x1b[0m`;
+}
+
+const c = {
+	border: (s: string) => rgb("#ff6b5f", s),
+	borderDim: (s: string) => rgb("#8b514a", s),
+	cyan: (s: string) => rgb("#00d7ff", s),
+	green: (s: string) => rgb("#00ff8a", s),
+	gold: (s: string) => rgb("#f6b85a", s),
+	muted: (s: string) => rgb("#7a6d62", s),
+};
+
+function stripAnsi(text: string): string {
+	return text.replace(ANSI_RE, "");
+}
+
+function padAnsi(text: string, width: number): string {
+	const clipped = truncateToWidth(text, width, "");
+	return clipped + " ".repeat(Math.max(0, width - visibleWidth(clipped)));
+}
+
+function line(width: number, side: "top" | "bottom", original = ""): string {
+	if (width < 20) return c.border("─".repeat(width));
+
+	const isTop = side === "top";
+	const leftCorner = isTop ? "╭" : "╰";
+	const rightCorner = isTop ? "╮" : "╯";
+	const strippedOriginal = stripAnsi(original);
+	const scrollMatch = strippedOriginal.match(/[↑↓] \d+ more/);
+
+	const leftLabel = isTop
+		? `${c.border(leftCorner + "─")} ${c.cyan("π")} ${c.muted("•")} ${c.green("ZERO")} ${c.muted("•")} ${c.gold("prompt")} `
+		: `${c.border(leftCorner + "─")} ${c.muted("ctrl+j newline")} `;
+	const rightLabel = isTop
+		? ` ${scrollMatch ? c.gold(scrollMatch[0]) : c.muted("Enter ↵")} ${c.border("─" + rightCorner)}`
+		: ` ${c.muted("esc stop")} ${c.border("─" + rightCorner)}`;
+
+	const fill = Math.max(1, width - visibleWidth(leftLabel) - visibleWidth(rightLabel));
+	return leftLabel + c.borderDim("─".repeat(fill)) + rightLabel;
+}
+
+function isHorizontalEditorLine(text: string): boolean {
+	const stripped = stripAnsi(text).trim();
+	return /^─+$/.test(stripped) || /^─── [↑↓] \d+ more/.test(stripped);
+}
+
+function patchEditor(): void {
+	const proto = Editor.prototype as unknown as {
+		render: (width: number) => string[];
+		[PATCHED]?: boolean;
+	};
+	if (proto[PATCHED]) return;
+	proto[PATCHED] = true;
+
+	const originalRender = proto.render;
+	proto.render = function prettyEditorRender(width: number): string[] {
+		if (width < 24) return originalRender.call(this, width);
+
+		const innerWidth = Math.max(1, width - 2);
+		const raw = originalRender.call(this, innerWidth);
+		if (raw.length < 3) return originalRender.call(this, width);
+
+		const bottomIndex = raw.findIndex((rawLine, index) => index > 0 && isHorizontalEditorLine(rawLine));
+		const resolvedBottomIndex = bottomIndex === -1 ? raw.length - 1 : bottomIndex;
+		const result: string[] = [];
+
+		result.push(line(width, "top", raw[0]));
+		for (let i = 1; i < resolvedBottomIndex; i++) {
+			result.push(`${c.border("│")} ${padAnsi(raw[i], innerWidth - 2)} ${c.border("│")}`);
+		}
+		result.push(line(width, "bottom", raw[resolvedBottomIndex]));
+		for (let i = resolvedBottomIndex + 1; i < raw.length; i++) {
+			result.push(`${c.border("│")} ${padAnsi(raw[i], innerWidth - 2)} ${c.border("│")}`);
+		}
+
+		return result;
+	};
+}
+
+export default function (_pi: ExtensionAPI) {
+	patchEditor();
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gonrocca/zero-pi",
-  "version": "0.1.64",
+  "version": "0.1.66",
   "description": "zero-pi — an installable layer for pi (pi.dev): the zero spec-driven development workflow (clarify → explore → plan → analyze → build → veredicto) with automatic clarify/analyze gates, per-phase model autotune, and token-efficient batched builds. Adds capability to pi without modifying pi.",
   "type": "module",
   "keywords": [
@@ -25,7 +25,9 @@
     "image": "https://raw.githubusercontent.com/gonzalonicolasr/zero-pi/main/assets/preview.png",
     "extensions": [
       "./extensions/zero-banner.ts",
-      "./extensions/zero-statusline.ts",
+      "./extensions/zero-hud.ts",
+      "./extensions/zero-pretty-code-fences.ts",
+      "./extensions/zero-pretty-input-box.ts",
       "./extensions/working-phrases.ts",
       "./extensions/win-tree-kill.ts",
       "./extensions/sdd-agents.ts",
@@ -54,6 +56,9 @@
     "themes",
     "assets/preview.png",
     "extensions/zero-banner.ts",
+    "extensions/zero-hud.ts",
+    "extensions/zero-pretty-code-fences.ts",
+    "extensions/zero-pretty-input-box.ts",
     "extensions/zero-statusline.ts",
     "extensions/working-phrases.ts",
     "extensions/win-tree-kill.ts",