command-code 1.79.2 → 1.81.0

package/CHANGELOG.md

@@ -1,5 +1,19 @@
 # command-code
 
+## 1.81.0
+
+### Minor Changes
+
+- feat: add `codemode` tool that lets the model write scripts to orchestrate tool calls, MCP only by default, change via /config
+
+## 1.80.0
+
+### Minor Changes
+
+- feat: Mods Hub + ModApi
+- feat: add muse wonder
+- fix: show mod user follow-ups in the feed when consumed and reserve prompt newline shortcuts.
+
 ## 1.79.2
 
 ### Patch Changes

package/dist/bundled/command-code-knowledge/reference/models.md

@@ -116,6 +116,7 @@ The model catalog — every id `/model`, `--model`, `model:effort` shorthand, an
 | `meta/muse-spark-1.2-contributor` | Muse Spark 1.2 Contributor | 1.05M | low, medium, high, xhigh | $0.1/$0.2 · cache $0.002 | Go and above | Muse Spark 1.2 at ~95% off |
 | `meta/muse-spark-1.3` | Muse Spark 1.3 | 1.05M | low, medium, high, xhigh, max | $1.25/$4.25 · cache $0.15 | GOAT and above | multimodal reasoning for long-horizon agentic and coding workflows |
 | `meta/muse-spark-1.3-contributor` | Muse Spark 1.3 Contributor | 1.05M | low, medium, high, xhigh | $0.1/$0.2 · cache $0.002 | Go and above | Muse Spark 1.3 at up to 95% off |
+| `meta/muse-wonder-1.0` | Muse Wonder | 1.05M | low, medium, high, xhigh | $4/$20 · cache $0.2 | Max | frontier coding, long-running agents and advanced computer use |
 ## xAI
 
 | Id (use EXACTLY this) | Name | Context | Efforts | $/1M in/out · cache read | Min plan | Best for |

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

@@ -337,6 +337,7 @@ Valid model ids (the /model catalog — use these EXACT ids):
 - meta/muse-spark-1.2-contributor
 - meta/muse-spark-1.3
 - meta/muse-spark-1.3-contributor
+- meta/muse-wonder-1.0
 - nvidia/nemotron-3-ultra-550b-a55b
 - poolside/laguna-s-2.1-free
 - inclusionai/ling-3.0-flash-sante:free

package/dist/bundled/command-code-knowledge/reference/tools.md

@@ -439,6 +439,58 @@ MCP tools are hidden entirely in plan mode - Command Code can't verify a remote
 
 ---
 
+## Codemode
+
+The `codemode` tool lets the model write a short JavaScript script that calls other tools. Instead of one tool call per round trip, the model writes a script that does several steps and runs it in one go: it loops, fans out with `Promise.all`, and filters, and only what it prints or returns reaches the context. A chain of MCP calls with a filter at the end becomes one call:
+
+```js
+const issues = await tools.mcp__linear__list_issues({team: "Core"});
+return issues.filter(issue => issue.open).map(issue => issue.id);
+```
+
+| Parameter | Type | Required | Description |
+| --- | --- | --- | --- |
+| `code` | string | yes | The body of an async function. Top-level `await` and `return` work. |
+| `timeout_ms` | number | no | Deadline for the whole script. Default 120,000, between 1,000 and 600,000. |
+
+### Configure codemode
+
+Codemode has three modes, set in `/config`. The mode decides when the tool is offered to the model and which tools a script may call.
+
+- **MCP tools.** The default. The tool is offered whenever an MCP server is connected, and scripts can call the MCP tools. Everything else works as before: MCP tools can still be loaded and called directly.
+- **Read-only and MCP tools.** The tool is offered in every session. Scripts can call the MCP tools and the read-only built-in tools: reading files and directories, glob, grep, web search, and the todo and task tools. These tools are made script-first and are removed from context, so that the model uses them through codemode.
+- **Off.** Disables codemode completely.
+
+In every mode, a script can never edit or write files, run commands, ask the user a question, review a plan, switch plan mode, load tools, or start another script.
+
+### Globals
+
+| Global | What it does |
+| --- | --- |
+| `tools.<name>(args)` | Calls a tool. One object argument, shaped like the tool's parameters. |
+| `ALL_TOOLS` | The tools this script may call, with a one-line description each. |
+| `searchTools("query")` | Finds callable tools by description. |
+| `describeTool("name")` | Returns a tool's full schema. |
+| `CWD` | The working directory. |
+| `text(...)`, `console.log(...)` | Print a line. |
+| `return`, `exit()` | Send back a value; end the script early. |
+| `store("key", value)`, `load("key")` | Keep a JSON value across scripts in the session. |
+
+### Permissions
+
+Every nested call is a real tool call: same mode filter, permission rules, input repair, and output truncation as a direct call, with prompts one at a time. `codemode` itself is read-only and never prompts, since it can do no more than the calls it makes. It is hidden in any mode that leaves a script nothing to call, such as plan mode under the default setting.
+
+### Limits
+
+Scripts run in a sandbox with no file system, network, timers, or process access; the tool bridge is the only way out.
+
+- 128 MB of memory, one sandbox per call
+- 8 nested calls in flight at once
+- 1 MB of printed output, after which the script fails; 25,000 tokens reach the model
+- 256 KB per stored value, 1 MB per session store
+
+---
+
 ## Permission modes & tool visibility
 
 Which tools the model even *sees* depends on the mode:

package/dist/bundled/config/references/settings.md

@@ -15,6 +15,7 @@ The executable registry is authoritative. Run `cmd config list --scope effective
 | `peek-recap-diagram` | user | boolean | `true`, `false` | When a task that changed files or ran commands finishes, draw one short text diagram recapping it (one extra model call per task, same as /peek). |
 | `peek-recap-delay` | user | enum | `0`, `1`, `2`, `5`, `10`, `15`, `30`, `60` | Recap a finished task only when this long passed since your last message, so a quick back-and-forth is not recapped every time (same as /peek delay). |
 | `image-vision` | user | enum | `ask`, `enabled`, `disabled` | Let a text-only model read attached images by describing them with the vision model ("Ask on first use" prompts the first time you attach an image). |
+| `codemode` | user | enum | `mcp`, `tools`, `off` | The codemode tool lets the model write a short code script that can call several tools and run it in one go: fewer round trips, less raw tool output in context. Scripts never edit, write, or run commands. |
 | `branch-summary-skip-prompt` | user | boolean | `true`, `false` | Never ask about summarizing when switching branches in /tree. |
 | `default-export-format` | user | enum | `html`, `jsonl`, `md` | Format a bare /export (no format or path) writes — an explicit /export html\|jsonl\|md\|<path> always overrides. |
 | `default-share-gist-format` | user | enum | `html`, `jsonl`, `md` | Format a bare /share gist (no format argument) posts — an explicit /share gist html\|jsonl\|md always overrides. |

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

@@ -114,9 +114,13 @@ run `pnpm generate:knowledge` after editing the docs under `packages/docs/src/ap
 ## 6. Ship it (optional)
 
 - Personal: leave it in `~/.commandcode/mods/`.
-- A package: a `package.json` with `{"commandcode": {"mods": ["./index.ts"]}}`, installed via
-  `cmd mods add npm:<name>` / `cmd mods add owner/repo` / `cmd mods add ./local-dir`.
-  Full packaging/filtering detail: `reference/packaging.md`.
+- A package: a `package.json` with `{"keywords": ["cmd-mod"], "commandcode": {"mods": ["./index.ts"]}}`,
+  installed via `cmd mods add npm:<name>` / `cmd mods add owner/repo` / `cmd mods add ./local-dir`.
+  **Always include the `cmd-mod` keyword** — it is what lists the package on the
+  [mods hub](https://commandcode.ai/mods) once it is published to npm; without it the mod is
+  invisible there. Add a kind keyword too (`cmd-mod-tool`, `cmd-mod-command`, …) and a
+  `repository` field so the hub row shows the right category and a star count. Full
+  packaging/filtering detail: `reference/packaging.md`.
 
 ## Boundaries to state up front
 

package/dist/bundled/mod-builder/examples/kitchen-sink.ts

@@ -92,13 +92,32 @@ export default function (cmd: ModApi): void {
 	// ── observe events (never mutate here) ──────────────────────────────────────────────
 	cmd.on('tool_errored', () => cmd.ui.notify('a tool errored', 'warning'));
 
+	// ── a keyboard shortcut (interactive TUI only; dispatched after host bindings) ──────
+	cmd.addShortcut('alt+u', {
+		description: 'Show context usage',
+		handler: () => {
+			const usage = cmd.getContextUsage();
+			if (!usage || usage.percent === null)
+				return {message: 'context window not measured yet'};
+			return {
+				message: `${cmd.getModel()} · ${usage.percent}% of ${usage.contextWindow} tokens`,
+			};
+		},
+	});
+
+	// ── skills shipped beside this mod (resolved against this file) ────────────────────
+	// cmd.addSkillsPath('./skills');
+
 	// ── live surfaces (usable any time after the harness binds) ─────────────────────────
-	// cmd.ui.notify / confirm / select / input — talk to the user.
+	// cmd.ui.notify / confirm / select / input — talk to the user; ui.setTitle — the tab.
 	// cmd.queueMessage({content, deliverAs}) — steer the running loop or queue a follow-up.
+	// cmd.sendUserMessage(text) — a real user turn (starts one when idle).
 	// cmd.session — durable custom-entry persistence (undefined until bound).
 	// cmd.sessions — compact(), tree(), leafId(), navigateTree(...), setLabel(...).
-	// cmd.setModel / setEffort / setSessionName.
+	// cmd.setModel / setEffort / setSessionName, and their get* counterparts.
+	// cmd.getContextUsage / getCommands / getToolInfo / isIdle — live reads.
 	// cmd.getAllTools / getActiveTools / setActiveTools — a mod-managed tool filter.
+	// cmd.shutdown() — exit once the turn settles.
 	//
 	// Example: on the first run, greet once via a queued steering message.
 	let greeted = false;

package/dist/bundled/mod-builder/reference/api.md

@@ -25,6 +25,8 @@
 | `cmd.addFlag` | `(name, {type: 'boolean'\|'string'; default?; description?}) => Disposable` |
 | `cmd.addProvider` | `(module: ProviderModule) => Disposable` |
 | `cmd.addRenderer` | `(customType: string, (data) => readonly string[]) => Disposable` |
+| `cmd.addShortcut` | `(keys: string, {description?; handler}) => Disposable` |
+| `cmd.addSkillsPath` | `(path: string) => Disposable` |
 | `cmd.on` | `(event: AgentEventType \| 'session_start' \| 'session_shutdown', handler) => Disposable` |
 
 What each does:
@@ -36,6 +38,8 @@ What each does:
 - `cmd.on(event, handler)` - observe any `AgentEvent` plus the host lifecycle events `session_start` / `session_shutdown` (fired when a harness binds the host and when a session switch or dispose replaces it). Handlers are isolated: a throw becomes a `mod_error {hook: 'on:<event>'}` event, never a crash.
 - `cmd.addProvider(providerModule)` - register a model provider through the same `ProviderModule` seam the built-ins use (id, transport, auth hooks, model list). The host appends mod providers to its set - mods extend the provider set, never replace it.
 - `cmd.addRenderer(customType, data => lines)` - a renderer for a custom entry type; returns the lines to print (style them with ansi escapes - picocolors, `@commandcode/tui` helpers, or raw codes). First registration per type wins across mods.
+- `cmd.addShortcut(keys, {description, handler})` - a keyboard shortcut in the interactive TUI. `keys` is a `modifier+key` chord that **must include Ctrl or Alt** (`alt+r`, `ctrl+r`); a modifier-less or Shift-only chord (`p`, `enter`, `shift+p`) is rejected with a warning, because it would also type into the prompt, and so is a `Ctrl+Shift` chord whose key reaches the terminal as a bare control byte — letters, digits, Enter, Tab, Backspace (`ctrl+shift+p`, `ctrl+shift+enter`) — where the Shift never arrives (arrow / navigation keys keep their modifiers, so `ctrl+shift+up` is fine). `ctrl+m`, `ctrl+i`, `ctrl+h` and `ctrl+[` are rejected too: terminals send them as Enter, Tab, Backspace and Escape. A chord a built-in already owns (`ctrl+c`, `ctrl+o`, an editor key like `ctrl+k`) is rejected the same way — the host's own bindings run first, so it would never fire — and so are the keys the prompt handles itself (`alt+w`, `ctrl+z`, `ctrl+g`, `ctrl+s`, `ctrl+v`, `alt+v`), which stay taken even when rebound. The handler gets the same `{args, ui, cwd, exec}` context a command handler does and may return the same `{message}` / `{prompt}` result. The host dispatches mod shortcuts AFTER its own bindings, so a mod can add keys but never shadow interrupt, exit, mode cycling, or the transcript toggles; `Esc` stays host-owned. First registration per chord wins across mods; `/hotkeys` lists them under **Mods**. Headless hosts never fire shortcuts.
+- `cmd.addSkillsPath(path)` - an extra skills location (one skill directory, or a directory of skills) for this session's skill discovery. Relative paths resolve against the mod's own file, so a package can point at the `./skills` it ships. Collected at factory time. A package can declare the same thing without code through its manifest - see [What a package ships](./packaging.md#what-a-package-ships).
 
 ## Live methods (any time after the harness binds)
 
@@ -44,15 +48,29 @@ What each does:
 | `cmd.getFlag` | `(name) => boolean \| string \| undefined` |
 | `cmd.showEntry` | `(customType, data?) => void` |
 | `cmd.queueMessage` | `({content, deliverAs?: 'steer' \| 'follow-up'}) => void` |
+| `cmd.sendUserMessage` | `(content, {deliverAs?}) => void` |
 | `cmd.exec` | `({command, args?, cwd?, signal?}) => Promise<{stdout, stderr, code}>` |
 | `cmd.setSessionName` / `setModel` / `setEffort` | `(value) => void` (buffered pre-bind) |
+| `cmd.getSessionName` / `getModel` / `getEffort` | `() => value \| undefined` (undefined pre-bind) |
+| `cmd.getContextUsage` | `() => {tokens, contextWindow, percent} \| undefined` |
+| `cmd.getCommands` | `() => readonly {name, description?, mod}[]` |
+| `cmd.isIdle` | `() => boolean` |
+| `cmd.shutdown` | `() => void` |
 | `cmd.getAllTools` / `getActiveTools` | `() => readonly string[]` |
+| `cmd.getToolInfo` | `() => readonly {name, description, readOnly, active}[]` |
 | `cmd.setActiveTools` | `(names: readonly string[]) => void` |
 
 Details:
 
-- `cmd.ui` - `notify` (a `notice` feed row), `confirm` / `select` / `input` (the Interaction question modal in the TUI; deterministic defaults headless: false/undefined), `setStatus`, `widget`, `refreshWidgets`. The full dialog/status/widget contract is in [UI surface](./ui.md#ui-surface).
-- `cmd.queueMessage({content, deliverAs})` - `steer` lands after the current tool batch (behind any queued user messages in the same poll), `follow-up` only when the run would stop (ahead of continuation nudges, behind queued user input).
+- `cmd.ui` - `notify` (a `notice` feed row), `confirm` / `select` / `input` (the Interaction question modal in the TUI; deterministic defaults headless: false/undefined), `setStatus`, `widget`, `refreshWidgets`, `setTitle`. The full dialog/status/widget contract is in [UI surface](./ui.md#ui-surface).
+- `cmd.queueMessage({content, deliverAs})` - `steer` lands after the current tool batch (behind any queued user messages in the same poll), `follow-up` only when the run would stop (ahead of continuation nudges, behind queued user input). Queued messages steer a run that is already going; they never START one.
+- `cmd.sendUserMessage(content, {deliverAs})` - a REAL user message: echoed in the feed like typed input and, when the agent is idle, starting a turn right away. While a run is going, `steer` (default) queues it behind the active turn exactly as typing would, and `follow-up` holds it until the run would stop. Headless there is no submit path, so it falls back to `queueMessage` with the same `deliverAs`.
+- `cmd.getSessionName()` / `getModel()` / `getEffort()` - the live values behind the setters; `undefined` before a session binds.
+- `cmd.getContextUsage()` - `{tokens, contextWindow, percent}` for the bound session: `tokens` and `percent` are `null` until the first model call has measured the window (never a misleading 0%).
+- `cmd.getCommands()` - every slash command mods registered on this host (`{name, description, mod}`), so a mod can discover siblings or avoid a taken name. Built-in commands are host-owned and not listed.
+- `cmd.isIdle()` - `false` while an agent run is in flight on the bound harness (`run_start` … `run_end`), `true` otherwise and pre-bind.
+- `cmd.shutdown()` - asks the interactive host to exit once the current turn settles (the same path as `/exit`). Headless: no-op - the print run ends on its own.
+- `cmd.getToolInfo()` - the registered tools with `description`, `readOnly`, and `active` (per the mod-managed filter) - the descriptive counterpart of `getAllTools()`'s bare names.
 - `cmd.session` - the `ModSessionApi` persistence seam (appendCustomEntry / appendCustomMessageEntry / getCustomEntries), undefined until bound. See [ModContext.session - the mods' persistence surface](./hooks-and-events.md#mod-context-session-the-mods-persistence-surface).
 - `cmd.showEntry(customType, data)` - render a custom entry into the live feed through the renderer registered for that type (unrendered types pretty-print as JSON). The TUI wires the sink; headless runs drop entries. Pair with `cmd.session.appendCustomEntry` when the data should also persist.
 - `cmd.sessions` - live session controls: `compact()`, `tree()` (the session branch tree as stable `{id, label, children}` nodes), `leafId()`, `navigateTree({targetId, summarize?, customInstructions?})`, and `setLabel({targetId, label})`. These read live harness state, so unlike the buffered setters they throw with a clear message when no session is bound yet.

package/dist/bundled/mod-builder/reference/packaging.md

@@ -44,12 +44,56 @@ A package declares what it ships via `package.json` - exact paths, directories,
 ```json
 {
 	"name": "@team/review-mod",
-	"commandcode": {"mods": ["./src/review.ts", "src/checks/*.ts"]}
+	"description": "Blocks risky diffs and adds a /review command.",
+	"keywords": ["cmd-mod", "cmd-mod-tool", "cmd-mod-command"],
+	"repository": "https://github.com/team/review-mod",
+	"commandcode": {
+		"mods": ["./src/review.ts", "src/checks/*.ts"],
+		"skills": ["./skills"]
+	}
 }
 ```
 
+The `cmd-mod` keyword is **required** — it is the only thing that lists your package on the
+[mods hub](https://commandcode.ai/mods). Everything else shapes the hub row: a `description`
+becomes the summary, a kind keyword (`cmd-mod-tool`, `cmd-mod-command`, `cmd-mod-hook`,
+`cmd-mod-provider`, `cmd-mod-renderer`, `cmd-mod-flag`) sets the category badge, and a
+`repository` pointing at GitHub adds the star count. Ship these from the start so the hub
+lists the mod well the moment you publish, with nothing to submit.
+
 No manifest → the `mods/` convention directory → a root `index.ts`, in that order.
 
+`commandcode.skills` lists skill directories the package ships beside its mods (each entry is one skill directory or a directory of skills, relative to the package root; entries escaping the root are dropped). They join skill discovery for every session the package loads in, so one `cmd mods add` brings the mods and the skills that go with them. A mod can contribute the same thing from code with `cmd.addSkillsPath`.
+
+Publish to npm with the `cmd-mod` keyword and the package is listed on the [mods hub](https://commandcode.ai/mods) automatically - the hub reads the npm registry for that keyword, so there is nothing to submit. Monthly downloads come straight from npm; a GitHub `repository` field adds the star count.
+
+## Listing a git-only mod (the curated registry)
+
+Two things feed [the hub](https://commandcode.ai/mods). Any npm package with the `cmd-mod` keyword lists automatically (above). A **curated registry** - `mods/registry.json` in the public [`CommandCodeAI/command-code`](https://github.com/CommandCodeAI/command-code) repo - adds what npm can't: mods that live only in a git repo and never hit npm, richer metadata layered over an npm entry (matched by `npm`), an `official` badge, and a `hidden` list for moderation. Open a PR against that file to get a git-only mod listed - nothing else to submit.
+
+```json
+{
+	"version": 1,
+	"hidden": [],
+	"mods": [
+		{
+			"name": "review-guard",
+			"source": "owner/review-guard",
+			"description": "Blocks risky diffs and adds a /review command.",
+			"author": {"name": "Ada", "github": "ada"},
+			"repo": "https://github.com/owner/review-guard",
+			"kinds": ["tool", "command"],
+			"tags": ["safety", "review"],
+			"official": false
+		}
+	]
+}
+```
+
+`name`, `source` (what `cmd mods add <source>` takes), `description` (≤240 chars), `author.name`, and at least one `kinds` value (`tool`/`command`/`hook`/`provider`/`renderer`/`flag`) are required; `repo`, `npm`, `tags`, `official`, and `addedAt` are optional. A GitHub `repo` adds a live star count, `npm` merges the entry with its npm package for the download count, `official` marks a team-maintained mod, and a `hidden` name (a mod or an npm package) keeps spam or impersonation off the hub. The schema is `mods.schema.json` beside the file.
+
+The resolved list - npm discovery merged with the curated file, live numbers included - is served at [`commandcode.ai/mods.json`](https://commandcode.ai/mods.json), CORS-open, so the CLI or any script can read the same list the hub renders.
+
 ## Filtering a source's mods
 
 A `mods.sources` entry can be the object form to load only part of a package:

package/dist/bundled/mod-builder/reference/ui.md

@@ -6,8 +6,9 @@ Everything a mod can put on screen rides `cmd.ui`, `cmd.addRenderer`, and `cmd.s
 
 ## Notifications and dialogs
 
-- `cmd.ui.notify(message)` - a `notice` feed row.
+- `cmd.ui.notify(message, level?)` - a `notice` feed row, styled by `level`: `'info'` (default) is a dim bullet, `'warning'` an amber ⚠, `'error'` a red ⚠. Rendered during a turn (the per-turn feed projector); a notice raised at factory time flushes once the session binds.
 - `cmd.ui.confirm({title, message?})` / `cmd.ui.select({title, options})` / `cmd.ui.input({title, placeholder?})` - the Interaction question modal in the TUI. Headless, each resolves its deterministic default: confirm → `false`, select/input → `undefined` - never auto-approved.
+- `cmd.ui.setTitle(text | null)` - the terminal tab title. The text replaces the session title on the tab (and survives the host's own title re-assertions) until `null` hands the tab back. Headless: no-op.
 
 ## Footer status segments and editor widgets
 
@@ -59,4 +60,8 @@ Rendering is deliberately **line-based, not component-based**: mods return style
 | `select` / `input` | modal | resolves `undefined` |
 | `setStatus` | footer segment under the input | stored, rendered nowhere |
 | `widget` | no-op (wire-up pending) | no-op |
+| `setTitle` | terminal tab title | no-op |
 | `showEntry` | rendered feed row | dropped |
+| `addShortcut` | dispatched after host bindings | never fires |
+| `sendUserMessage` | real user turn (queued while busy) | falls back to `queueMessage` |
+| `shutdown` | exits after the turn settles | no-op |