command-code 1.82.5 → 1.84.0

package/CHANGELOG.md

@@ -1,5 +1,23 @@
 # command-code
 
+## 1.84.0
+
+### Minor Changes
+
+- feat: Add `/statusline` to customize what shows on the line under the input
+
+## 1.83.0
+
+### Minor Changes
+
+- feat: Planning and Implementation models follow the live model catalog
+- feat: mods get panes, widgets, toasts, hot reload, permission answers, transcript redaction, per-request model routing
+- feat: mods can use `cmd.state` / `cmd.store` / `cmd.clock` / `cmd.model` / `cmd.prompt`, sub-agent types, `/mods`, `cmd mods inspect`, and `--safe-mode`
+- feat: panes host `cmd.ui` input, select, and markdown elements with a keyboard focus model (Alt+↑, Tab, Esc), docking beside the prompt on wide terminals
+- feat: mods can copy to the clipboard with `cmd.ui.copy` and play sounds with `cmd.audio.play` / `cmd.audio.bell`
+- feat: mods can rewrite the model's answer as it streams via `hooks.transformTextDelta` (committed text matches what was shown) and stream a child process's output with `cmd.process.spawn`
+- feat: mods can restyle built-in TUI rows with `cmd.ui.override` (spinner, tool rows, user messages, command output), never the permission prompt
+
 ## 1.82.5
 
 ### Patch Changes

package/dist/bundled/command-code-knowledge/live-models.ts

@@ -81,7 +81,39 @@ function changedSinceBuild(model: CatalogModelV1): boolean {
 	);
 }
 
-function bucketModels(effective: EffectiveModelCatalog): ModelBuckets {
+export interface LiveModelSessionModel {
+	readonly id: string;
+	// The catalog the session model runs on: the session pin, which may be older than the section's.
+	readonly catalog: EffectiveModelCatalog;
+}
+
+// A row answers to its id and its aliases, as the catalog resolves ids.
+function rowNames(row: CatalogModelV1, id: string): boolean {
+	return row.id === id || row.aliases.includes(id);
+}
+
+// The session model's row from the catalog it runs on, so the section never tells the model a
+// window or effort levels the session is not running on; any other model's row as served.
+interface ServedRowParams {
+	readonly model: CatalogModelV1;
+	readonly sessionModel?: LiveModelSessionModel;
+}
+
+function servedRow(params: ServedRowParams): CatalogModelV1 {
+	const {model, sessionModel} = params;
+	if (!sessionModel || !rowNames(model, sessionModel.id)) return model;
+	return (
+		sessionModel.catalog.catalog.models.find(row =>
+			rowNames(row, sessionModel.id),
+		) ?? model
+	);
+}
+
+function bucketModels(params: {
+	readonly effective: EffectiveModelCatalog;
+	readonly sessionModel?: LiveModelSessionModel;
+}): ModelBuckets {
+	const {effective, sessionModel} = params;
 	const known = listSelectableModelIds({catalog: builtCatalog()});
 	const knownSet = new Set(known);
 	const added: CatalogModelV1[] = [];
@@ -97,11 +129,12 @@ function bucketModels(effective: EffectiveModelCatalog): ModelBuckets {
 			continue;
 		}
 		if (state !== 'selectable') continue;
-		if (!knownSet.has(model.id)) {
-			added.push(model);
+		const row = servedRow({model, sessionModel});
+		if (!knownSet.has(row.id)) {
+			added.push(row);
 			continue;
 		}
-		if (changedSinceBuild(model)) changed.push(model);
+		if (changedSinceBuild(row)) changed.push(row);
 	}
 	// A shipped id the catalog no longer carries at all (no row, no alias), or now marks update
 	// required, is refused by /model and sub-agents too.
@@ -119,6 +152,8 @@ function bucketModels(effective: EffectiveModelCatalog): ModelBuckets {
 
 export interface BuildLiveModelSectionParams {
 	readonly catalog?: EffectiveModelCatalog;
+	// The session's model and its pin, when the pin knows it: that row wins over `catalog`'s.
+	readonly sessionModel?: LiveModelSessionModel;
 }
 
 /**
@@ -132,7 +167,10 @@ export function buildLiveModelSection(
 	const effective =
 		params.catalog ?? getInstalledModelCatalogManager()?.getEffective();
 	if (!effective) return '';
-	const {added, hidden, outdated, changed} = bucketModels(effective);
+	const {added, hidden, outdated, changed} = bucketModels({
+		effective,
+		sessionModel: params.sessionModel,
+	});
 	if (added.length + hidden.length + outdated.length + changed.length === 0)
 		return '';
 	const parts = [
@@ -166,23 +204,42 @@ export function buildLiveModelSection(
 	return parts.join('\n\n');
 }
 
+// One built section, keyed by the inputs it was built from.
+interface LiveModelSectionMemo {
+	readonly catalog: EffectiveModelCatalog;
+	readonly sessionModel: LiveModelSessionModel | undefined;
+	readonly text: string;
+}
+
+function sameSessionModel(
+	left: LiveModelSessionModel | undefined,
+	right: LiveModelSessionModel | undefined,
+): boolean {
+	return left?.id === right?.id && left?.catalog === right?.catalog;
+}
+
 /**
- * The section built once per catalog `getCatalog` answers with. A session hands in its pin when the
- * pin came from the live catalog, else the newest catalog — so every activation (the activate_skill
- * tool, a `/command-code-knowledge` turn, an inline mention) reads the same text until a catalog
- * lands or /model re-pins.
+ * The section built once per catalog and session model `getParams` answers with. A session hands in
+ * its pin when the pin came from the live catalog, else the newest catalog, plus its own model held
+ * to the pin — so every activation (the activate_skill tool, a `/command-code-knowledge` turn, an
+ * inline mention) reads the same text until a catalog lands or /model re-pins.
  */
 export function createLiveModelSectionCache(
-	getCatalog: () => EffectiveModelCatalog | undefined,
+	getParams: () => BuildLiveModelSectionParams,
 ): () => string {
-	let cached:
-		| {readonly catalog: EffectiveModelCatalog; readonly text: string}
-		| undefined;
+	let cached: LiveModelSectionMemo | undefined;
 	return () => {
-		const catalog = getCatalog();
+		const {catalog, sessionModel} = getParams();
 		if (!catalog) return '';
-		if (cached?.catalog !== catalog) {
-			cached = {catalog, text: buildLiveModelSection({catalog})};
+		if (
+			cached?.catalog !== catalog ||
+			!sameSessionModel(cached.sessionModel, sessionModel)
+		) {
+			cached = {
+				catalog,
+				sessionModel,
+				text: buildLiveModelSection({catalog, sessionModel}),
+			};
 		}
 		return cached.text;
 	};

package/dist/bundled/command-code-knowledge/reference/custom-slash-commands.md

@@ -38,6 +38,7 @@ Every built-in command, grouped by area. Aliases are shown in parentheses on the
 | `/unshare`                     | Stop sharing conversation                                                                             |
 | `/exit` (`/quit`)              | Exit Command Code                                                                                     |
 | `/reload`                      | Restart Command Code and resume this session (applies a staged update)                                |
+| `/mods`                        | List loaded [mods](https://commandcode.ai/docs/mods) and panes; `/mods reload [name]` hot-reloads, `/mods open\|close <pane>`     |
 
 ### Context & compaction
 
@@ -121,6 +122,7 @@ Every built-in command, grouped by area. Aliases are shown in parentheses on the
 | `/config [query]`  | Search and change settings                                     |
 | `/theme [dark\|light\|auto]` | Switch themes; `auto` matches your terminal background |
 | `/status`          | Show comprehensive environment status                          |
+| `/statusline [off\|on\|reset]` | Configure Command Code's statusline UI (terminal only) |
 | `/changelog [all]` | See what's new in Command Code (`all` for the full history)    |
 | `/learn`           | Open the Command Code learn hub in your browser                |
 | `/update`          | Update Command Code to the latest version                      |
@@ -152,6 +154,7 @@ Most commands are **blocked mid-turn** - mode flips, session switches, model cha
 - `/session-file` - read-only session facts
 - `/copy` - clipboard only
 - `/todos` (also `ctrl+x`) - edits local todo state, most useful mid-turn while a plan is being driven (needs the `todos` mod enabled)
+- `/statusline off`, `/statusline on`, `/statusline reset` - a local display preference (bare `/statusline` opens its editor once the turn ends)
 - `/exit` / `/quit` - always available
 - `/goal clear` - stops the goal loop; the current step finishes, then the loop stops. Setting a **new** goal mid-turn is refused with a busy notice.
 
@@ -165,6 +168,128 @@ Most other commands - `/clear`, `/mode`, `/plan`, `/model`, `/compact`, `/worktr
 
 `/loop <interval> <task>` runs the task now and repeats it on a fixed cadence such as `5m`, `2h`, `1d`, or a trailing `every 2 hours`. `/loop <task>` runs it now and lets the agent pick each next delay, between one minute and one hour. Bare `/loop` runs the default maintenance task, which a `.commandcode/loop.md` file replaces. Esc cancels the conversation's loops. The [`/loop`](https://commandcode.ai/docs/loop) page has the normalization rules, `loop.md`, and resume behavior.
 
+### `/statusline` in detail
+
+The status line is the row directly under the input. It stays visible while you type and steps aside only for the slash menu, the `@` file list, the slash hint, and a pending Ctrl+C exit:
+
+```text
+> fix the parser
+  branch: main · mymod: ok
+  ? for shortcuts · PR #5329 · taste on
+```
+
+Bare `/statusline` slash command opens the statusline editor. Select items from the list to add to the statusline. An item with nothing to show right now says why in brackets beside its label, for example `Git branch (not on a git branch)`, instead of showing a placeholder.
+
+These items sit in the row, in the order you choose. Items marked *off* are unchecked by default:
+
+| **Item**          | **Shows**                                                                          |
+| ----------------- | ---------------------------------------------------------------------------------- |
+| Model             | This session's model (*off*)                                                       |
+| Model + reasoning | The model and its reasoning level, e.g. `Opus 4.7 with high effort` (*off*)        |
+| Reasoning level   | The reasoning level alone, e.g. `high effort` (*off*)                              |
+| Current directory | The working directory, e.g. `~/work/app` (*off*)                                   |
+| Git branch        | The checked-out branch, e.g. `branch: main`; re-read after each turn (*off*)       |
+| Session name      | The session's name, from `/rename` or the generated title (*off*)                  |
+| Version           | The Command Code version, e.g. `v1.77.0` (*off*)                                   |
+| Phase model       | The planning or implementation model, while one is in charge; always at the right end of the row |
+
+These items keep their own place under the input; you can only turn them on or off. All are on by default:
+
+| **Item**          | **Controls**                                                                       |
+| ----------------- | ---------------------------------------------------------------------------------- |
+| Permission mode   | The accept-edits and plan mode badges. Bypass and dont-ask always show             |
+| IDE context       | The IDE file or selection and the IDE connection indicator                         |
+| Pull request      | The open or merged PR badge for this branch, as a link                             |
+| Taste learning    | `taste on` or `taste off` (`taste off (byok)` when a BYOK session skips learning)  |
+| Background tasks  | Running shells and monitors; press `↓` to manage them                              |
+| Shortcut hints    | `? for shortcuts` and the paste hint. The stash badge shows whenever a prompt is stashed |
+
+The Ctrl+C exit prompt, credit warnings, and update, share and taste notices always show.
+
+| **Key**            | **Action**                                                 |
+| ------------------ | ---------------------------------------------------------- |
+| `↑` / `↓`          | Move between items                                         |
+| `Space` / `Enter`  | Check or uncheck the focused item                          |
+| `←` / `→`          | Move the focused item left or right in the row (only row items move; Phase model stays at the right end) |
+| `Esc`              | Save your changes and close (just close if nothing changed; during a save, close at once; after another session's change, discard yours) |
+| `Ctrl+C`           | Close without saving                                       |
+
+Unchecked items keep their place, so checking one again puts it back where it was. Nothing changes under the input until Esc saves the layout. If the write fails, the editor stays open with your changes, and Esc tries again; if another session changed the layout while you were editing, it never overwrites it: Enter reloads the saved version, Esc discards your changes. Closing the editor gives you back the prompt you were writing.
+
+Output from [mods](https://commandcode.ai/docs/mods) (`cmd.ui.setStatus`) always appears after the built-ins, and before the phase model at the right end, in the order the mods loaded. Unchecking every built-in still shows mod output; `/statusline off` is the way to hide the whole row.
+
+#### Add your own items with mods
+
+The editor lists only the built-in items. To show anything else in the row, such as a CI result, a ticket number or a count, use a [mod](https://commandcode.ai/docs/mods) that calls `cmd.ui.setStatus(text)`. Each mod gets one segment: a new call replaces its text, and `null` removes it. You don't need to write the mod yourself; describe what you want and Command Code builds it:
+
+```text copy filename="Prompt"
+Build me a mod that shows how many files I've changed in this git repo in my status line, in yellow, and updates it after every turn. Show nothing when the tree is clean.
+```
+
+Command Code writes something like this and saves it in `~/.commandcode/mods/changed-files.ts`, where it loads in every session:
+
+```ts copy filename="~/.commandcode/mods/changed-files.ts"
+import type {ModApi} from '@commandcode/harness';
+
+export default function (cmd: ModApi): void {
+	const refresh = async (): Promise<void> => {
+		const {stdout, code} = await cmd.exec({command: 'git', args: ['status', '--porcelain']});
+		const count = stdout.split('\n').filter(Boolean).length;
+		// null clears the segment: nothing shows on a clean tree or outside a repo.
+		cmd.ui.setStatus(code === 0 && count > 0 ? `\u001b[33m✎ ${count} changed\u001b[39m` : null);
+	};
+
+	cmd.hooks({onSessionStart: refresh});
+	cmd.on('turn_end', () => void refresh());
+}
+```
+
+The next session shows it in the row:
+
+```text
+> fix the parser
+  ✎ 2 changed
+  ? for shortcuts · PR #5329 · taste on
+```
+
+To try a mod without installing it, run `cmd --mod ./changed-files.ts`; after editing an installed one, run `/reload`. Mod text can use ANSI colors and OSC 8 links; other escape codes are removed. To hide mod output but keep the built-ins, set `legacy-mods` to `"enabled": false` in `config.json` (see below). The [UI surface](https://commandcode.ai/docs/mods#ui-surface) section of the mods page has the full `setStatus` contract.
+
+| **Command**          | **Effect**                                                                        |
+| -------------------- | --------------------------------------------------------------------------------- |
+| `/statusline`        | Open the editor                                                                   |
+| `/statusline off`    | Hide the whole row, mod output included. Your selection is kept, and the on/off-only items above are unaffected |
+| `/statusline on`     | Show the row again with your saved selection, or the default one                 |
+| `/statusline reset`  | Forget your layout and go back to the default, in the order above                |
+
+Your items always get exactly one line under the input, in the order you set. When they don't fit your terminal, the line is cut with `…` at the edge rather than wrapping or reordering. The phase model sits at the right end of that line when it fits beside it, otherwise at the right end of the line below.
+
+The layout is saved in `~/.commandcode/config.json` under `statusline`. You rarely need to edit it by hand:
+
+```json
+{
+  "statusline": {
+    "version": 1,
+    "enabled": true,
+    "items": [
+      {"id": "model", "enabled": false},
+      {"id": "pull-request", "enabled": true},
+      {"id": "taste", "enabled": true},
+      {"id": "phase-model", "enabled": true},
+      {"id": "background-tasks", "enabled": true},
+      {"id": "git-branch", "enabled": true},
+      {"id": "permission-mode", "enabled": true},
+      {"id": "legacy-mods", "enabled": true}
+    ]
+  }
+}
+```
+
+`items` sets the order, except that `phase-model` always draws at the right end. `enabled: false` on an item unchecks it; `enabled: false` at the top level is `/statusline off`. An item missing from `items` is unchecked, except the on/off-only items (`permission-mode`, `ide`, `pull-request`, `taste`, `background-tasks`, `hints`), which stay on. Other ids: `model-reasoning`, `reasoning`, `cwd`, `session-name`, `version`. `legacy-mods` is where mod output goes; leave it out (or set `"items": []`) and mod output is hidden.
+
+A layout saved by a newer version of Command Code is never overwritten: the row uses the default layout and the editor opens read-only, until you update or run `/statusline reset`. A `statusline` value that isn't valid is also left untouched and shown read-only; fix or remove the `statusline` key, or run `/statusline reset`. If `config.json` itself isn't valid JSON, nothing can save the layout, `/statusline reset` included, until you fix or remove that file.
+
+The row doesn't watch the file. A hand edit, or a save from another Command Code window, shows up the next time you open `/statusline`, run `/statusline off`, `on` or `reset`, or restart.
+
 ### `/rc` in detail
 
 Bare `/rc` opens the picker: platform, setup, permission mode. `/rc default`, `/rc auto-accept` and `/rc yolo` connect straight into a mode. `/rc status` reports what is on, `/rc off` disconnects, and `/rc off clear` also deletes the bot's own messages. `/rc` is refused when the model asks for it and when it arrives from the chat, so the bot cannot change its own token or allowlist. See [`/rc`](https://commandcode.ai/docs/remote-control) for setup and what the chat can send.

package/dist/bundled/command-code-knowledge/reference/product-help.md

@@ -68,11 +68,13 @@
 - /pr-comments: Fetch all PR comments for current branch
 - /add-dir: Manage additional directory scope
 - /status: Show comprehensive environment status
+- /statusline [off|on|reset]: Configure Command Code's statusline UI: pick and order the row under the input (model, reasoning, phase model, directory, git branch, session name, version) and turn the mode badge, IDE context, PR, taste, background tasks and shortcut hints on or off; mod status follows. Terminal only
 - /usage: Display credits, plan, and usage metrics
 - /upgrade: Open billing page to upgrade your plan
 - /extra: Buy extra usage at API cost, zero markup
 - /update: Update Command Code to the latest version
 - /reload: Restart Command Code and resume this session (applies a staged update)
+- /mods: List loaded mods and panes; /mods reload [name] hot-reloads, /mods open|close <pane>
 - /help: Display help information
 - /exit: Exit Command Code
 - /quit: Exit Command Code (alias of /exit)
@@ -139,6 +141,7 @@
 - --base <branch>: Base branch for a new cloud session
 - --mod <path>: Load a mod file or directory for this session (repeatable)
 - --mod-option <name=value>: Set a mod-declared flag value (repeatable)
+- --safe-mode: Load built-in mods only for this session (no installed mods, no --mod)
 - --skill <path>: Load extra skills from a path (a skill directory or a directory of skills); repeatable
 - --no-skills: Skip skill discovery; paths given via --skill still load
 - --skip-onboarding: Skip taste onboarding (for automated runs)

package/dist/bundled/mod-builder/SKILL.md

@@ -59,6 +59,7 @@ the job to the seam, then open the matching example file:
 | react to what happens | `cmd.on(event, handler)` | `examples/observe-events.ts` |
 | print custom styled feed rows | `cmd.addRenderer` + `cmd.showEntry` | `examples/custom-entry-renderer.ts` |
 | take configurable options | `cmd.addFlag` + `cmd.getFlag` | `examples/flags-and-options.ts` |
+| rewrite the answer as it streams / stream a process's output | `cmd.hooks({transformTextDelta})` + `cmd.process.spawn` | `examples/stream-filter.ts` |
 | everything at once (a tour) | — | `examples/kitchen-sink.ts` |
 
 ## 3. The one rule: hooks mutate, `on` observes

package/dist/bundled/mod-builder/examples/model-router.ts

@@ -0,0 +1,43 @@
+// Example mod: route requests between models, and call a model yourself.
+//
+// hooks.beforeModelRequest runs at the start of each request's round, so its tools and prompt are
+// built for the model it picks. Returning {model} sends THAT request to another model; the next request goes back to the session's model (use
+// prepareNextTurn to switch for the rest of a run). Here: the first request of each run, which
+// usually just reads the prompt and picks tools, goes to a cheaper model.
+//
+// cmd.model.complete runs one prompt on the session's own client, with no transcript and no
+// tools. It always resolves: {isAnswered: true, text} or {isAnswered: false, reason}.
+
+import type {ModApi} from '@commandcode/harness';
+
+export default function (cmd: ModApi): void {
+	cmd.addFlag('router-model', {
+		type: 'string',
+		description: 'Model for the first request of each run',
+	});
+
+	cmd.hooks({
+		beforeModelRequest: async ({turnNumber}) => {
+			const cheap = cmd.getFlag('router-model');
+			if (turnNumber !== 1 || typeof cheap !== 'string' || !cheap)
+				return undefined;
+			return {model: cheap};
+		},
+	});
+
+	cmd.addCommand({
+		name: 'haiku',
+		description:
+			'Write a haiku about the argument with a one-shot model call',
+		argumentHint: '<topic>',
+		handler: async ({args}) => {
+			const result = await cmd.model.complete({
+				prompt: `Write a haiku about: ${args || 'code review'}`,
+				maxOutputTokens: 200,
+			});
+			if (!result.isAnswered)
+				return {message: `No haiku (${result.reason}).`};
+			return {message: result.text};
+		},
+	});
+}

package/dist/bundled/mod-builder/examples/pane-and-buttons.ts

@@ -0,0 +1,60 @@
+// Example mod: a live pane with buttons, a band above the prompt, and a toast.
+//
+// cmd.ui.pane draws a titled panel the person opens and closes; cmd.ui.widget draws a band of
+// lines around the prompt. Both take a `render` that returns plain data: strings, or elements
+// ({type: 'text' | 'row' | 'box' | 'button' | 'progress' | 'divider'}). Never React components,
+// so the same mod draws in any host.
+//
+// Values a drawing reads live in cmd.state: host-held, so they survive a hot reload, and
+// setting one repaints every widget and pane. While the pane is open, Alt+<hotkey> presses its
+// buttons and Alt+0 closes it.
+
+import type {ModApi} from '@commandcode/harness';
+
+export default function (cmd: ModApi): void {
+	const calls = (): number => cmd.state.get<number>('calls') ?? 0;
+
+	cmd.on('tool_completed', () => {
+		cmd.state.set('calls', calls() + 1);
+	});
+
+	// The band above the prompt: one line, always visible.
+	cmd.ui.widget({
+		placement: 'above-editor',
+		render: () => [
+			{type: 'text', text: `tool calls: ${calls()}`, dim: true},
+		],
+	});
+
+	cmd.ui.pane({
+		id: 'calls',
+		title: 'Tool calls',
+		render: () => [
+			{type: 'progress', label: 'budget', value: calls() / 50, width: 20},
+			{
+				type: 'row',
+				children: [
+					{type: 'text', text: `${calls()} of 50`, bold: true},
+					{
+						type: 'button',
+						label: 'Reset',
+						hotkey: 'r',
+						onPress: () => {
+							cmd.state.set('calls', 0);
+							cmd.ui.toast('Counter reset', {level: 'success'});
+						},
+					},
+				],
+			},
+		],
+	});
+
+	// /calls opens the pane.
+	cmd.addCommand({
+		name: 'calls',
+		description: 'Show the tool-call counter pane',
+		handler: () => {
+			cmd.ui.openPane('calls');
+		},
+	});
+}

package/dist/bundled/mod-builder/examples/pane-form.ts

@@ -0,0 +1,68 @@
+// Example mod: a small form in a pane, with a text input, a select, markdown, and a button.
+//
+// `input` and `select` elements only take keys while their pane has focus: `/standup` opens the
+// pane with focus (dialog-like), and Alt+↑ focuses the newest open pane from the prompt. While
+// focused, Tab walks the fields, ←/→ choose an option, Enter submits or picks, and Esc goes
+// back to the prompt. Typing never reaches a pane that does not have focus.
+//
+// The values live in cmd.state, so they survive a hot reload and setting one repaints the pane.
+
+import type {ModApi} from '@commandcode/harness';
+
+const MOODS = [
+	{label: 'Great', value: 'great'},
+	{label: 'Okay', value: 'okay'},
+	{label: 'Blocked', value: 'blocked'},
+] as const;
+
+export default function (cmd: ModApi): void {
+	const note = (): string => cmd.state.get<string>('note') ?? '';
+	const mood = (): string => cmd.state.get<string>('mood') ?? 'okay';
+
+	cmd.ui.pane({
+		id: 'standup',
+		title: 'Standup',
+		render: () => [
+			{
+				type: 'markdown',
+				text: '**Today**: one line, then pick how it is going.',
+			},
+			{
+				type: 'input',
+				key: 'note',
+				placeholder: 'what are you working on?',
+				value: note(),
+				onSubmit: text => cmd.state.set('note', text.trim()),
+			},
+			{
+				type: 'select',
+				key: 'mood',
+				options: MOODS,
+				value: mood(),
+				onSelect: value => cmd.state.set('mood', value),
+			},
+			{
+				type: 'button',
+				label: 'Post',
+				hotkey: 's',
+				onPress: () => {
+					if (!note()) {
+						cmd.ui.toast('Type a note first', {level: 'warning'});
+						return;
+					}
+					cmd.ui.notify(`standup (${mood()}): ${note()}`);
+					cmd.ui.closePane('standup');
+				},
+			},
+		],
+	});
+
+	// /standup opens the form with the keyboard in it.
+	cmd.addCommand({
+		name: 'standup',
+		description: 'Post a one-line standup from a form pane',
+		handler: () => {
+			cmd.ui.openPane('standup', {focus: true});
+		},
+	});
+}

package/dist/bundled/mod-builder/examples/permission-policy.ts

@@ -0,0 +1,34 @@
+// Example mod: answer permission prompts with a team policy.
+//
+// hooks.onPermissionRequest fires ONLY where Command Code was about to ask you. Deny rules,
+// plan mode, and dont-ask have already run, so a mod can never undo them. Return 'allow' or
+// 'deny' to answer for the person, or undefined to let them decide. A prompt a safety check
+// forced (isSafetyPrompt: a sensitive file, a risky command) can be denied but never allowed:
+// an 'allow' there is ignored and you are asked as usual.
+
+import type {ModApi} from '@commandcode/harness';
+
+// Anything that can chain or redirect a second command goes to the person: without this,
+// `git status && npm publish` would pass as a safe `git status`.
+const SHELL_CONTROL = /[;&|`<>\n]|\$\(/;
+
+// Anchored at both ends, so the whole command must be one of these.
+const SAFE_SHELL = [
+	/^git (status|diff|log)( .*)?$/,
+	/^pnpm (test|lint|typecheck)( .*)?$/,
+];
+
+export default function (cmd: ModApi): void {
+	cmd.hooks({
+		onPermissionRequest: ({toolName, input}) => {
+			if (toolName !== 'shell_command') return undefined;
+			const command =
+				typeof input.command === 'string' ? input.command : '';
+			if (/\bcurl\b.*\|\s*(ba)?sh\b/.test(command)) return 'deny';
+			if (SHELL_CONTROL.test(command)) return undefined;
+			if (SAFE_SHELL.some(pattern => pattern.test(command)))
+				return 'allow';
+			return undefined;
+		},
+	});
+}

package/dist/bundled/mod-builder/examples/redact-secrets.ts

@@ -0,0 +1,46 @@
+// Example mod: redact secrets from everything the transcript keeps.
+//
+// hooks.transformMessage sees every message before it is committed: your prompt, each model
+// reply, every tool result, steering and follow-up messages. What it returns is what the
+// transcript stores AND what every later request sends, so a key a tool printed never reaches
+// the model on the next turn. The role and every tool_use / tool_result id must stay as they
+// were; a rewrite that changes them is rejected and the message is kept.
+
+import type {ModApi} from '@commandcode/harness';
+
+const SECRET_PATTERNS = [
+	/\bsk-[A-Za-z0-9_-]{16,}\b/g, // API keys
+	/\bgh[pousr]_[A-Za-z0-9]{20,}\b/g, // GitHub tokens
+	/\bAKIA[0-9A-Z]{16}\b/g, // AWS access key ids
+];
+
+function redact(text: string): string {
+	return SECRET_PATTERNS.reduce(
+		(current, pattern) => current.replace(pattern, '[REDACTED]'),
+		text,
+	);
+}
+
+export default function (cmd: ModApi): void {
+	cmd.hooks({
+		transformMessage: ({message}) => {
+			if (message.role === 'assistant') return message;
+			return {
+				...message,
+				content: message.content.map(block => {
+					if (block.type === 'text')
+						return {...block, text: redact(block.text)};
+					if (block.type !== 'tool_result') return block;
+					return {
+						...block,
+						content: block.content.map(part =>
+							part.type === 'text'
+								? {...part, text: redact(part.text)}
+								: part,
+						),
+					};
+				}),
+			};
+		},
+	});
+}

package/dist/bundled/mod-builder/examples/spinner-count.ts

@@ -0,0 +1,47 @@
+// Example mod: restyle built-in rows with cmd.ui.override.
+//
+// `spinner` appends nodes after the working status line, so "tool calls: 3" sits beside the
+// spinner while the agent works. `tool_row` draws a tool's row instead of the built-in one;
+// returning undefined keeps the built-in row, and `next()` is what mods loaded after this one
+// drew (undefined when nobody did). A throwing override falls back to the built-in drawing.
+//
+// The permission prompt is never overridable: what a person approves is always drawn by the host.
+
+import type {ModApi, ModUiOverrideProps} from '@commandcode/harness';
+
+function statusMark(status: ModUiOverrideProps['tool_row']['status']): string {
+	if (status === 'error') return '✗';
+	if (status === 'pending') return '…';
+	return '✓';
+}
+
+export default function (cmd: ModApi): void {
+	const calls = (): number => cmd.state.get<number>('calls') ?? 0;
+
+	cmd.on('tool_completed', () => {
+		cmd.state.set('calls', calls() + 1);
+	});
+	// One count per run: reset when the agent starts working on a new prompt.
+	cmd.on('run_start', () => {
+		cmd.state.set('calls', 0);
+	});
+
+	cmd.ui.override('spinner', (_props, next) => [
+		{type: 'text', text: `tool calls: ${calls()}`, color: 'cyan'},
+		...(next() ?? []),
+	]);
+
+	// Shell rows as one compact line; every other tool keeps its built-in row.
+	cmd.ui.override('tool_row', ({toolName, input, status}) => {
+		if (toolName !== 'shell_command') return undefined;
+		return [
+			{
+				type: 'row',
+				children: [
+					{type: 'text', text: statusMark(status), bold: true},
+					{type: 'text', text: `$ ${input}`, dim: true},
+				],
+			},
+		];
+	});
+}