pi-native-output-styles 0.4.0 → 0.6.0

package/CHANGELOG.md

@@ -1,5 +1,34 @@
 # Changelog
 
+## 0.6.0
+
+### Added
+
+- `/output-style config` for the two settings worth persisting. It runs from the user config file, so both apply to every session and project:
+  - `config default <style|off>` — the style new sessions start with.
+  - `config indicator <status|widget|off>` — where the active style is shown; `status` is the default.
+- Run `config` with no arguments for a dialog per setting. A bare key reads the value back, an unknown key is an error, and a run without a dialog UI prints the config instead.
+- A `widget` indicator renders the style above the editor. Every refresh writes both surfaces, so switching modes can never leave a stale badge.
+
+### Changed
+
+- `config` joins the management words in the command router. `configure this style` still routes to the agent.
+- Clearing a saved default now merges state instead of overwriting the file, so it no longer drops the indicator setting.
+
+## 0.5.0
+
+One command, plus a bundled style and an agent that maintains styles.
+
+### Added
+
+- `/output-style <request>` hands the task to an agent that reviews, rewrites, or creates styles. The brief is short Markdown in `extensions/prompts/output-style-leader.md`, and the agent decides for itself whether to fan work out to other agents.
+- Bundled `caveman` style, from [carlosduplar/caveman-output-style-claude-code](https://github.com/carlosduplar/caveman-output-style-claude-code) (MIT, © 2026 Carlos Mello).
+
+### Changed
+
+- **`/style` is gone; `/output-style` is the only command.** A single word that names a style, `off`, or `none` is style management; anything else is a request for the agent. `/output-style` with no arguments lists what exists.
+- Style names are matched case-insensitively and resolved to their declared name.
+
 ## 0.4.0
 
 Repackaged as `pi-native-output-styles` — a Pi-only output-style switcher built on Pi's native `.pi/` directories.

package/LICENSE

@@ -2,6 +2,8 @@ MIT License
 
 Copyright (c) 2026 LoneExile
 Copyright (c) 2026 code-koan contributors
+The bundled `caveman` output style is Copyright (c) 2026 Carlos Mello
+(https://github.com/carlosduplar/caveman-output-style-claude-code), MIT.
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

package/README.md

@@ -4,7 +4,7 @@
 [![npm version](https://img.shields.io/npm/v/pi-native-output-styles.svg)](https://www.npmjs.com/package/pi-native-output-styles)
 [![license](https://img.shields.io/npm/l/pi-native-output-styles.svg)](./LICENSE)
 
-Named, swappable system-prompt styles for [Pi](https://pi.dev) — with a live `/style` switcher. Unlike Claude Code's output styles (which need `/clear` to switch), styles here apply and switch **live, mid-session**.
+Named, swappable system-prompt styles for [Pi](https://pi.dev), plus an agent that can review, rewrite, and create them for you. Unlike Claude Code's output styles (which need `/clear` to switch), styles here apply and switch **live, mid-session**.
 
 Styles and saved defaults live in Pi's own directories: `~/.pi/agent/output-styles/` and `<repo>/.pi/output-styles/`.
 
@@ -19,17 +19,41 @@ pi install git:github.com/code-koan/pi-native-output-styles
 
 Then start a **new** session. Extensions do not hot-reload.
 
-## Use
+## One command
 
-- `/style` — show the active style and list the available ones.
-- `/style <name>` — activate a style for this session.
-- `/style <name> --save` — also save it as your personal (user) default.
-- `/style <name> --project` — save it as the project default (committed with the repo).
-- `/style off` — clear the active style for this session, overriding any saved default.
-- `/style off --save` / `/style off --project` — also clear the saved default. `none` is an alias for `off`.
-- While composing `/style`, a hint line below the input shows the available flags.
+`/output-style` does both jobs. What you type decides which one you get.
 
-The style is applied every turn, and the status line shows `style: eli5`.
+**Switch styles** — the first word is a style name, `off`, or nothing:
+
+```text
+/output-style                          list styles and show the active one
+/output-style caveman                  use caveman for this session
+/output-style concise --save           and make it your default
+/output-style concise --project        save it as this project's default
+/output-style off                      clear it; --save / --project also clears the default
+```
+
+**Ask the agent to work on a style** — anything else:
+
+```text
+/output-style review the reviewer style
+/output-style 重写这个 output style，让它更简洁、更适合编程
+/output-style 创建一个适合代码 Review 的 output style
+```
+
+**Configure it** — `/output-style config`:
+
+```text
+/output-style config                       interactive: pick the default and the indicator
+/output-style config default caveman       set the cross-session default
+/output-style config default off           clear it
+/output-style config indicator widget      where the active style shows
+/output-style config indicator             read one setting back
+```
+
+The rule is one line: *`config` and a single word that names a style, `off`, or `none` are management; anything else is a request for the agent.* So `/output-style concise` activates, and `/output-style rewrite concise` asks. To review a style whose name you would otherwise activate, say more than its name.
+
+While composing the command, a hint line under the editor shows both forms.
 
 ## How a style is applied
 
@@ -37,9 +61,23 @@ Pi's assembled system prompt is flat prose plus XML blocks — there is no perso
 
 It is idempotent: a prompt that already carries the marker is left untouched, so switching styles mid-session never stacks a second block. Nothing else in the prompt is modified.
 
+## The style agent
+
+`/output-style <request>` hands the task to the agent with a short brief and the live picture: which style is active, both writable directories, and every style that exists with its tier and file path.
+
+The agent owns the task end to end. It decides for itself whether the work needs other agents — a review is the usual case, where prompt quality, responsibility boundaries, and conflicts/redundancy are worth splitting across children. It uses whatever delegation tool the session has, and does the analysis itself when there is none. The final write and the summary stay with it.
+
+Review findings are specific: conflicting instructions, duplicate or unenforceable rules, vague wording, over-constraining the model, content that belongs to a different concern, AI-slop voice, and rules that are hard to follow while actually working. Rewrites keep what works, delete what does not, and add only what is missing.
+
+A review reports; it does not edit. The file is written only when the request asks for a change. In observed runs the agent delegated on its own when a task had several independent angles to check, and worked solo on a small single-file review.
+
+The brief lives in [`extensions/prompts/output-style-leader.md`](extensions/prompts/output-style-leader.md) and is plain Markdown — edit it without touching code.
+
 ## Bundled styles
 
-`concise` · `explanatory` · `teacher` · `reviewer` · `diagrams-first` · `ste` · `eli5`
+`caveman` · `concise` · `explanatory` · `teacher` · `reviewer` · `diagrams-first` · `ste` · `eli5`
+
+`caveman` is [Carlos Mello's Caveman output style](https://github.com/carlosduplar/caveman-output-style-claude-code) — terse replies, no filler, same technical signal. The same repo also ships a more aggressive `caveman-ultra`; it is not bundled, but you can drop it into your own `output-styles/` directory unchanged.
 
 `ste` writes in [ASD-STE100](https://asd-ste100.org) Simplified Technical English, with the v2.0 action-first reply shape for person-addressed replies, tasks, issues, pull request descriptions, and commit messages. Adapted from [Ege Chelebi's ste-writing skill](https://github.com/woosal1337/blog/blob/9240b25eac013467554fd8217f319743aa0282b8/videos/ep01-the-cure-for-ai-slop/asd-ste100/SKILL.md).
 
@@ -60,21 +98,36 @@ description: Teach as you go
 Act as a patient teacher. Explain the concept before applying it.
 ```
 
-The body becomes the `# Personality` block.
+`name` is lowercase kebab-case, `description` is one line and shows up in `/output-style`.
 
 Precedence:
 
 - **Definitions** (low → high): bundled < user < project.
-- **Which style is active**: session `/style` > user default > project default.
+- **Which style is active**: session `/output-style` > user default > project default.
 
 ## Config
 
+`/output-style config` holds the two things that are worth setting once. Both live in `~/.pi/agent/output-styles.json`, so they apply to every session and every project without re-stating anything.
+
+| Key | Values | What it does |
+| --- | --- | --- |
+| `default` | a style name, or `off` | The style every new session starts with. Alias: `style`. |
+| `indicator` | `status`, `widget`, `off` | Where the active style shows. Default `status`. |
+
+A bare key reads the value back. An unknown key is an error, not a silent no-op. Running `config` with no arguments opens a dialog per setting; in a non-dialog run (print or JSON mode) it prints the current config instead.
+
+The indicator is a display preference, so like the default style the personal setting wins over a project one, and a project setting applies when you have none.
+
+To set a default without opening dialogs, `/output-style <name> --save` does the same thing.
+
+## File locations
+
 | | Path |
 | --- | --- |
 | Project styles | `<repo>/.pi/output-styles/` |
 | User styles | `~/.pi/agent/output-styles/` |
 | Project default (`--project`) | `<repo>/.pi/output-styles.json` |
-| User default (`--save`) | `~/.pi/agent/output-styles.json` |
+| User default + config (`--save`, `config`) | `~/.pi/agent/output-styles.json` |
 
 Environment:
 
@@ -91,4 +144,4 @@ bun x tsc --noEmit
 
 ## Credits
 
-Started as a fork of [LoneExile/pi-output-styles](https://github.com/LoneExile/pi-output-styles), reworked to use Pi's native `.pi/` directories. MIT licensed; original work © 2026 LoneExile.
+Started as a fork of [LoneExile/pi-output-styles](https://github.com/LoneExile/pi-output-styles). Bundles [caveman](https://github.com/carlosduplar/caveman-output-style-claude-code) by Carlos Mello. MIT licensed; original work © 2026 LoneExile, caveman style © 2026 Carlos Mello.

package/extensions/output-styles.ts

@@ -11,6 +11,21 @@ export interface Style {
   name: string;
   description: string;
   body: string;
+  /** Absolute file path; set by discoverStyles. */
+  path?: string;
+}
+
+/** Where a style definition was found. Only `project` and `user` are writable. */
+export type StyleTier = "bundled" | "user" | "project";
+
+export interface StyleSource {
+  dir: string;
+  tier: StyleTier;
+}
+
+export interface StyleEntry extends Style {
+  tier: StyleTier;
+  path: string;
 }
 
 type NotifyType = "info" | "warning" | "error";
@@ -20,11 +35,13 @@ interface ExtensionUI {
   setWidget(key: string, lines: string[] | undefined, options?: { placement: "aboveEditor" | "belowEditor" }): void;
   getEditorText(): string;
   notify(message: string, type?: NotifyType): void;
+  select?(title: string, options: string[]): Promise<string | undefined>;
 }
 
 interface ExtensionContext {
   cwd: string;
   hasUI: boolean;
+  isIdle?(): boolean;
   ui: ExtensionUI;
   setInterval?(callback: () => void, ms?: number): unknown;
 }
@@ -59,6 +76,7 @@ interface ExtensionAPI {
       handler: (args: string, ctx: ExtensionContext) => void | Promise<void>;
     },
   ): void;
+  sendUserMessage(content: string, options?: { deliverAs?: "steer" | "followUp" }): void;
 }
 
 export function parseStyle(text: string, fallbackName: string): Style {
@@ -99,7 +117,7 @@ export function discoverStyles(dirsLowToHigh: string[]): Map<string, Style> {
       }
       const style = parseStyle(text, entry.slice(0, -3));
       if (style.body.length === 0) continue;
-      styles.set(style.name, style);
+      styles.set(style.name, { ...style, path: join(dir, entry) });
     }
   }
   return styles;
@@ -126,13 +144,25 @@ export function bundledStylesDir(): string {
 
 export interface StyleState {
   active?: string;
+  indicator?: IndicatorMode;
+}
+
+/** Where the active style is shown. `status` is the default. */
+export const INDICATOR_MODES = ["status", "widget", "off"] as const;
+export type IndicatorMode = (typeof INDICATOR_MODES)[number];
+
+export function isIndicatorMode(value: unknown): value is IndicatorMode {
+  return typeof value === "string" && (INDICATOR_MODES as readonly string[]).includes(value);
 }
 
 export function readState(file: string): StyleState {
   try {
     const parsed: unknown = JSON.parse(readFileSync(file, "utf8"));
-    if (parsed && typeof parsed === "object" && "active" in parsed && typeof parsed.active === "string") {
-      return { active: parsed.active };
+    if (parsed && typeof parsed === "object") {
+      const state: StyleState = {};
+      if ("active" in parsed && typeof parsed.active === "string") state.active = parsed.active;
+      if ("indicator" in parsed && isIndicatorMode(parsed.indicator)) state.indicator = parsed.indicator;
+      return state;
     }
   } catch {
     // missing or malformed → empty
@@ -145,6 +175,13 @@ export function writeState(file: string, state: StyleState): void {
   writeFileSync(file, JSON.stringify(state, null, 2) + "\n");
 }
 
+// Merge, never replace: clearing the default must not drop the indicator
+// setting, and setting the indicator must not drop the default. A key passed
+// as undefined drops out of the JSON, which is how a key is cleared.
+export function updateState(file: string, patch: StyleState): void {
+  writeState(file, { ...readState(file), ...patch });
+}
+
 export function userStateFile(): string {
   return join(configHome(), "output-styles.json");
 }
@@ -162,6 +199,12 @@ export function resolveActiveName(
   return sessionActive ?? userState.active ?? projectState.active ?? null;
 }
 
+// The indicator is presentation, so it resolves from the same places as the
+// default style but falls back to the status bar.
+export function resolveIndicator(cwd: string): IndicatorMode {
+  return readState(userStateFile()).indicator ?? readState(projectStateFile(cwd)).indicator ?? "status";
+}
+
 const MARKER_PREFIX = "<!-- output-styles:";
 
 export function styleMarker(style: Style): string {
@@ -207,20 +250,51 @@ export function parseStyleCommandArgs(args: string): StyleCommandArgs {
   return { name, persist };
 }
 
+// One command serves every job, so the split has to be guessable from the
+// words alone. Rule, in order: the request is `config` when it starts with the
+// config word; empty, `off`, `none`, or a single word naming an existing style
+// is style management; anything else is a task for the agent. `/output-style
+// concise` activates; `/output-style rewrite concise` asks the agent.
+export type StyleCommandRoute =
+  | { kind: "config"; args: string }
+  | { kind: "manage" }
+  | { kind: "task"; request: string };
+
+export function routeStyleCommand(args: string, styleNames: Iterable<string>): StyleCommandRoute {
+  const request = args.trim();
+  if (request.length === 0) return { kind: "manage" };
+  if (/^config(?=\s|$)/i.test(request)) return { kind: "config", args: request.replace(/^config\s*/i, "").trim() };
+  const words = request.split(/\s+/).filter(t => t.length > 0 && !t.startsWith("--"));
+  if (words.length === 0) return { kind: "manage" }; // flags only
+  if (words.length > 1) return { kind: "task", request };
+  const word = words[0].toLowerCase();
+  if (OFF_WORDS[word]) return { kind: "manage" };
+  const known = new Set([...styleNames].map(n => n.toLowerCase()));
+  return known.has(word) ? { kind: "manage" } : { kind: "task", request };
+}
+
+// Routing matches names case-insensitively, but the style map is keyed by the
+// exact declared name, so the selected name has to be canonicalised before use.
+export function resolveStyleName(name: string, styleNames: Iterable<string>): string | null {
+  const all = [...styleNames];
+  return all.find(n => n === name) ?? all.find(n => n.toLowerCase() === name.toLowerCase()) ?? null;
+}
+
 const STATUS_KEY = "output-styles";
+const INDICATOR_KEY = "output-styles-indicator";
 const HINT_KEY = "output-styles-hint";
-// Persistent ghost hint shown below the editor while a `/style` command is
-// being composed. Pi only renders inline usage ghost text for builtin
-// commands, so this widget carries the same message for extension commands.
+// Persistent ghost hint shown below the editor while `/output-style` is being
+// composed. Pi only renders inline usage ghost text for builtin commands, so
+// this widget carries the same message for extension commands.
 const STYLE_HINT_LINES = [
-  "/style <name|off> [--save] [--project]",
-  "persist: --save (user default, --global alias) · --project (this project)",
+  "/output-style <name|off> [--save] [--project]",
+  "/output-style config — default style, indicator",
 ];
 
-// Pure matcher for the widget: show the hint while the input starts with a
-// `/style` command word (line start, with optional leading whitespace).
+// Pure matcher for the widget: show the hint while the input starts with the
+// `/output-style` command word (line start, optional leading whitespace).
 export function styleHintFor(text: string): string[] | null {
-  return /^\s*\/style(?:\s|$)/.test(text) ? STYLE_HINT_LINES : null;
+  return /^\s*\/output-style(?:\s|$)/.test(text) ? STYLE_HINT_LINES : null;
 }
 
 // Poller state: one started flag guards re-registration across in-process
@@ -259,9 +333,29 @@ export function startHintPoller(ctx: ExtensionContext): void {
 type SessionSelection = { type: "inherit" } | { type: "off" } | { type: "style"; name: string };
 let session: SessionSelection = { type: "inherit" };
 
-function styleDirs(cwd: string): string[] {
+export function styleSources(cwd: string): StyleSource[] {
   // low → high precedence: bundled < user < project
-  return [bundledStylesDir(), userStylesDir(), projectStylesDir(cwd)];
+  return [
+    { dir: bundledStylesDir(), tier: "bundled" },
+    { dir: userStylesDir(), tier: "user" },
+    { dir: projectStylesDir(cwd), tier: "project" },
+  ];
+}
+
+// One row per style name: the winning definition plus the file that actually
+// produced it, so a rewrite knows whether it may edit in place.
+export function styleCatalog(cwd: string): StyleEntry[] {
+  const byName = new Map<string, StyleEntry>();
+  for (const { dir, tier } of styleSources(cwd)) {
+    for (const style of discoverStyles([dir]).values()) {
+      if (style.path) byName.set(style.name, { ...style, tier, path: style.path });
+    }
+  }
+  return [...byName.values()].sort((a, b) => a.name.localeCompare(b.name));
+}
+
+function styleDirs(cwd: string): string[] {
+  return styleSources(cwd).map(s => s.dir);
 }
 
 // Argument completions for `/style <name>`: matches style names by prefix.
@@ -297,14 +391,150 @@ export function resolveActiveStyle(cwd: string, styles?: Map<string, Style>): St
   return map.get(name) ?? null;
 }
 
-function refreshStatus(ctx: ExtensionContext, style: Style | null): void {
-  if (!ctx.hasUI || typeof ctx.ui.setStatus !== "function") return;
-  ctx.ui.setStatus(STATUS_KEY, style ? `style: ${style.name}` : undefined);
+// One renderer for every call site, so switching the mode can never leave a
+// stale badge behind: both surfaces are written on every refresh, and only the
+// configured one gets text.
+function renderIndicator(ctx: ExtensionContext, style: Style | null): void {
+  if (!ctx.hasUI) return;
+  const mode = resolveIndicator(ctx.cwd);
+  const label = style ? `style: ${style.name}` : undefined;
+  if (typeof ctx.ui.setStatus === "function") {
+    ctx.ui.setStatus(STATUS_KEY, mode === "status" ? label : undefined);
+  }
+  if (typeof ctx.ui.setWidget === "function") {
+    ctx.ui.setWidget(INDICATOR_KEY, mode === "widget" && label ? [label] : undefined, { placement: "aboveEditor" });
+  }
+}
+
+// The Leader brief is plain Markdown next to the extension, so its wording can
+// be edited without touching code.
+export function leaderBrief(): string {
+  return readFileSync(join(dirname(fileURLToPath(import.meta.url)), "prompts", "output-style-leader.md"), "utf8").trim();
+}
+
+// The brief stays fixed and short. What changes per run is the live picture:
+// which style is active, where styles may be written, and what already exists.
+// The user's words are passed through untouched — this is a router, not a form.
+export function buildStyleTask(brief: string, cwd: string, active: Style | null, request: string): string {
+  const catalog = styleCatalog(cwd);
+  return [
+    brief,
+    "",
+    "## Context",
+    "",
+    `Active style: ${active?.name ?? "(none)"}`,
+    `Project style dir: ${projectStylesDir(cwd)}`,
+    `User style dir: ${userStylesDir()}`,
+    "",
+    "Available styles:",
+    ...(catalog.length
+      ? catalog.map(s => `- ${s.name} [${s.tier}] ${s.path}${s.description ? ` — ${s.description}` : ""}`)
+      : ["(none)"]),
+    "",
+    "## Request",
+    "",
+    request,
+  ].join("\n");
+}
+
+export type ConfigKey = "default" | "indicator";
+
+export interface ConfigArgs {
+  /** null means "no key given" — open the interactive flow. */
+  key: ConfigKey | null;
+  value: string;
+}
+
+const CONFIG_KEY_ALIASES: Record<string, ConfigKey> = {
+  default: "default",
+  style: "default",
+  indicator: "indicator",
+};
+
+// `null` means an unrecognised key; `{key: null}` means no key at all.
+export function parseConfigArgs(args: string): ConfigArgs | null {
+  const tokens = args.trim().split(/\s+/).filter(t => t.length > 0);
+  if (tokens.length === 0) return { key: null, value: "" };
+  const key = CONFIG_KEY_ALIASES[tokens[0].toLowerCase()];
+  if (!key) return null;
+  return { key, value: tokens.slice(1).join(" ") };
+}
+
+function describeConfig(cwd: string): string {
+  return `Default style (new sessions): ${readState(userStateFile()).active ?? "(none)"}\nStyle indicator: ${resolveIndicator(cwd)}`;
+}
+
+function applyConfigValue(key: ConfigKey, value: string, ctx: ExtensionContext, styles: Map<string, Style>): void {
+  const raw = value.trim();
+
+  if (key === "default") {
+    if (raw.length === 0) {
+      ctx.ui.notify(`Default style (new sessions): ${readState(userStateFile()).active ?? "(none)"}`, "info");
+      return;
+    }
+    if (OFF_WORDS[raw.toLowerCase()]) {
+      updateState(userStateFile(), { active: undefined });
+      ctx.ui.notify("Default style cleared. New sessions start with no style.", "info");
+      renderIndicator(ctx, resolveActiveStyle(ctx.cwd, styles));
+      return;
+    }
+    const name = resolveStyleName(raw, styles.keys());
+    if (!name) {
+      ctx.ui.notify(`Unknown style "${raw}". Available: ${[...styles.keys()].sort().join(", ") || "(none)"}`, "error");
+      return;
+    }
+    updateState(userStateFile(), { active: name });
+    ctx.ui.notify(`Default style → "${name}" for every new session and project.`, "info");
+    renderIndicator(ctx, resolveActiveStyle(ctx.cwd, styles));
+    return;
+  }
+
+  if (raw.length === 0) {
+    ctx.ui.notify(`Style indicator: ${resolveIndicator(ctx.cwd)}`, "info");
+    return;
+  }
+  if (!isIndicatorMode(raw)) {
+    ctx.ui.notify(`Indicator must be one of: ${INDICATOR_MODES.join(", ")}`, "error");
+    return;
+  }
+  updateState(userStateFile(), { indicator: raw });
+  ctx.ui.notify(`Style indicator → ${raw}`, "info");
+  renderIndicator(ctx, resolveActiveStyle(ctx.cwd, styles));
+}
+
+// Interactive path: two dialogs, then a summary. Falls back to printing when
+// the run has no dialog-capable UI (print/json modes).
+async function openConfigDialogs(ctx: ExtensionContext, styles: Map<string, Style>): Promise<void> {
+  if (typeof ctx.ui.select !== "function") {
+    ctx.ui.notify(describeConfig(ctx.cwd), "info");
+    return;
+  }
+
+  const current = readState(userStateFile()).active ?? "(none)";
+  const chosen = await ctx.ui.select(`Default output style for new sessions (now: ${current})`, [
+    "(keep current)",
+    "(none)",
+    ...[...styles.keys()].sort(),
+  ]);
+  if (chosen !== undefined && chosen !== "(keep current)") {
+    updateState(userStateFile(), { active: chosen === "(none)" ? undefined : chosen });
+  }
+
+  const mode = await ctx.ui.select(`Style indicator (now: ${resolveIndicator(ctx.cwd)})`, [
+    "(keep current)",
+    ...INDICATOR_MODES,
+  ]);
+  if (mode !== undefined && mode !== "(keep current)" && isIndicatorMode(mode)) {
+    updateState(userStateFile(), { indicator: mode });
+  }
+
+  renderIndicator(ctx, resolveActiveStyle(ctx.cwd, styles));
+  ctx.ui.notify(`Saved.\n${describeConfig(ctx.cwd)}`, "info");
 }
 
 export default function outputStyles(pi: ExtensionAPI): void {
   pi.on("session_start", (_event, ctx) => {
-    refreshStatus(ctx, resolveActiveStyle(ctx.cwd));
+    renderIndicator(ctx, resolveActiveStyle(ctx.cwd));
     if (started || !ctx.hasUI) return;
     started = true;
     startHintPoller(ctx);
@@ -318,27 +548,55 @@ export default function outputStyles(pi: ExtensionAPI): void {
     try {
       const style = resolveActiveStyle(ctx.cwd);
       if (!style) {
-        refreshStatus(ctx, null);
+        renderIndicator(ctx, null);
         return;
       }
       // Apply first; only reflect the style in the status line once the prompt
       // was actually augmented, so a swallowed throw never advertises a style
       // the turn did not apply.
       const systemPrompt = applyStyle(event.systemPrompt ?? "", style);
-      refreshStatus(ctx, style);
+      renderIndicator(ctx, style);
       return { systemPrompt };
     } catch {
       return; // never fail a turn over a styling concern
     }
   });
 
-  pi.registerCommand("style", {
+  pi.registerCommand("output-style", {
     description:
-      "Select an output style (injected as the # Personality block of the system prompt), or clear it. Usage: /style [name|off] [--save] [--project]",
+      "Select an output style, or ask the agent to review, rewrite, or create one. Usage: /output-style <name|off|what you want> [--save] [--project]",
     getArgumentCompletions: argumentPrefix => styleCompletions(argumentPrefix, process.cwd()),
-    handler: (args, ctx) => {
-      const { name, persist } = parseStyleCommandArgs(args);
+    handler: async (args, ctx) => {
       const styles = discoverStyles(styleDirs(ctx.cwd));
+      const route = routeStyleCommand(args, styles.keys());
+
+      if (route.kind === "config") {
+        const parsed = parseConfigArgs(route.args);
+        if (parsed === null) {
+          ctx.ui.notify("Config keys: default <style|off>, indicator <status|widget|off>", "error");
+          return;
+        }
+        if (parsed.key === null) await openConfigDialogs(ctx, styles);
+        else applyConfigValue(parsed.key, parsed.value, ctx, styles);
+        return;
+      }
+
+      if (route.kind === "task") {
+        let task: string;
+        try {
+          task = buildStyleTask(leaderBrief(), ctx.cwd, resolveActiveStyle(ctx.cwd, styles), route.request);
+        } catch (err) {
+          ctx.ui.notify(`Could not build the output-style task: ${String(err)}`, "error");
+          return;
+        }
+        // Mid-stream the delivery mode is required; otherwise the message goes
+        // out immediately and triggers the turn.
+        pi.sendUserMessage(task, ctx.isIdle?.() === false ? { deliverAs: "followUp" } : undefined);
+        return;
+      }
+
+      const { name: requested, persist } = parseStyleCommandArgs(args);
+      const name = requested === null ? null : (resolveStyleName(requested, styles.keys()) ?? requested);
       const available = [...styles.keys()].sort().join(", ") || "(none)";
 
       const unknownFlags = args
@@ -355,7 +613,11 @@ export default function outputStyles(pi: ExtensionAPI): void {
           .sort((a, b) => a.name.localeCompare(b.name))
           .map(s => (s.description ? `${s.name} — ${s.description}` : s.name))
           .join("\n");
-        ctx.ui.notify(`Active style: ${current?.name ?? "(none)"}\nAvailable:\n${listing || "(none)"}`, "info");
+        ctx.ui.notify(
+          `Active style: ${current?.name ?? "(none)"}\nAvailable:\n${listing || "(none)"}\n\n` +
+            "/output-style <name|off> [--save] [--project] to switch, or /output-style <request> to have the agent review, rewrite, or create a style.",
+          "info",
+        );
         return;
       }
       if (OFF_WORDS[name.toLowerCase()]) {
@@ -363,16 +625,16 @@ export default function outputStyles(pi: ExtensionAPI): void {
         let offScope = "this session";
         try {
           if (persist === "user") {
-            writeState(userStateFile(), {});
+            updateState(userStateFile(), { active: undefined });
             offScope = "cleared · user default";
           } else if (persist === "project") {
-            writeState(projectStateFile(ctx.cwd), {});
+            updateState(projectStateFile(ctx.cwd), { active: undefined });
             offScope = "cleared · project default";
           }
         } catch (err) {
           ctx.ui.notify(`Cleared for this session, but updating the saved default failed: ${String(err)}`, "warning");
         }
-        refreshStatus(ctx, null);
+        renderIndicator(ctx, null);
         ctx.ui.notify(`Output style off (${offScope}).`, "info");
         return;
       }
@@ -385,16 +647,16 @@ export default function outputStyles(pi: ExtensionAPI): void {
       let scope = "this session";
       try {
         if (persist === "user") {
-          writeState(userStateFile(), { active: name });
+          updateState(userStateFile(), { active: name });
           scope = "saved · user default";
         } else if (persist === "project") {
-          writeState(projectStateFile(ctx.cwd), { active: name });
+          updateState(projectStateFile(ctx.cwd), { active: name });
           scope = "saved · project default";
         }
       } catch (err) {
         ctx.ui.notify(`Applied for this session, but saving failed: ${String(err)}`, "warning");
       }
-      refreshStatus(ctx, styles.get(name) ?? null);
+      renderIndicator(ctx, styles.get(name) ?? null);
       ctx.ui.notify(`Output style → "${name}" (${scope}).`, "info");
     },
   });

package/extensions/prompts/output-style-leader.md

@@ -0,0 +1,71 @@
+# Output style task
+
+You own this end to end: read the request, decide what work it needs, do it,
+then verify what you produced. Finish with a short report of what changed and
+where.
+
+## What an output style is
+
+A style defines **how** you behave: voice, structure, level of detail,
+interaction style. It is not a home for project architecture, coding rules,
+domain knowledge, tooling conventions, or repo facts. Anything like that is a
+responsibility-boundary bug: drop it, or say where it belongs instead.
+
+## Delegation
+
+Decide for yourself whether the task needs other agents. Delegate only when
+independent angles genuinely improve the result. A review is the usual case:
+prompt quality, responsibility boundaries, and conflicts/redundancy are worth
+splitting. Use the `subagent` tool when it is available, and run the children
+in one workflow call. If it is not available, do the analysis yourself.
+Children report findings back to you and never write files. You do the final
+write and the final summary — never hand the file off.
+
+## Reviewing
+
+Review means report, not edit. Do not change the file unless the request also
+asks for the change; offer the fix instead.
+
+Name each finding specifically: what is wrong, what it costs, and the fix.
+Look for:
+
+- instructions that conflict with each other
+- duplicate, dead, or unenforceable rules
+- vague wording that cannot be acted on
+- over-constraining the model
+- content that belongs to another concern
+- AI-slop voice: inflated claims, filler, ceremony
+- rules that are hard to follow while actually working
+
+No praise padding, and do not restate the style back at the user.
+
+## Rewriting
+
+Keep what works, delete what does not, add only what is missing. Fewer sharp
+rules beat more rules. Do not add text to look thorough, and do not quietly
+widen the scope.
+
+## Creating
+
+Write the smallest style that achieves the goal. `name` is lowercase
+kebab-case; `description` is one line and shows up in `/style`.
+
+## File format
+
+    ---
+    name: <kebab-case>
+    description: <one line>
+    ---
+    <style body>
+
+## Where to write
+
+Default to the project directory. Write to the user directory only when asked
+for personal or global. Never edit a style under a package install path — those
+are read-only bundled styles; copy one out instead.
+
+## Before you finish
+
+- Re-read what you wrote: frontmatter plus body, nothing else.
+- Confirm the file parses and the `name` matches what `/style <name>` expects.
+- State the path you wrote and what changed.

package/extensions/styles/caveman.md

@@ -0,0 +1,11 @@
+---
+name: caveman
+description: Ultra-compact replies. Less fluff. Same technical signal.
+---
+
+Smart caveman style: terse responses, keep technical substance, drop ALL fluff.
+Lead with answer. Drop articles, filler, pleasantries, hedging, preamble, recap.
+Fragments OK. Pattern: `[thing] [action] [reason]. [next step].`
+Keep technical terms, code, commands, paths, JSON, errors unchanged.
+Bullets/tables only when scan > prose.
+Normal language for safety, irreversible actions, or confusion risk.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-native-output-styles",
-  "version": "0.4.0",
+  "version": "0.6.0",
   "description": "Named, swappable system-prompt styles for Pi — live /style switcher with native .pi/ directory support.",
   "keywords": [
     "pi-package",