faberwright 0.4.0 → 0.4.2

package/README.md

@@ -1,28 +1,15 @@
 # Faber
 
-**An agentic AI coding assistant for your terminal.** Give it a task in plain English; it explores your repository, edits files with your approval, runs your tests, and remembers your project across sessions.
+**A cost and performance efficient agentic AI coding assistant for your terminal.** Give it a task in plain English; it explores your repository, edits files with your approval, runs your tests, and remembers your project across sessions.
 
 *Faber — Latin for craftsman. Yours lives at `faber`.*
+* Read: [Faber Medium](https://medium.com/@jshial25/why-should-an-ai-coding-agent-read-hundreds-of-files-to-answer-one-question-d6369d29dfa5?postPublishedType=repub)
+## Code Graph
+<img width="636" height="573" alt="Screenshot 2026-08-09 at 2 58 30 PM" src="https://github.com/user-attachments/assets/176e5093-8e29-452f-a749-d06a561c583a" />
+
+## Demo 
+<img width="1240" height="700" alt="terminal_demo_compressed" src="https://github.com/user-attachments/assets/f78a8f68-130e-4f37-90f2-7a7089fa2653" />
 
-```
-$ faber "add input validation to the signup endpoint and cover it with tests"
-  ⚙ trace_path (from=main, to=handleSignup)
-  ⚙ read_file (path=app/routes/auth.ts)
-
-Proposed change to app/routes/auth.ts:
-@@ -12,6 +12,9 @@
-+  if (!isEmail(req.body.email)) return res.status(400)...
-Apply?   ↑/↓ then Enter
-❯ Yes
-  No
-  Always this session
-
-  ⚙ run_shell (command=npm test)
-─ result ────────────────────────────
-Added email/password validation to /signup, verified with 4 new passing tests.
-─────────────────────────────────────
-tokens: 31.2k in (78% cached) / 1.9k out · 7 calls
-```
 
 ## Your first session (2 minutes)
 
@@ -34,7 +21,7 @@ faber               # start the REPL (approval mode is on by default)
 1. **Give it a real task.** Try `add a comment explaining what the main entry file does`
 2. **Approve the diff** with the arrow keys and Enter. Cursor starts on Yes; "Always this session" grants trust. Shell commands ask too.
 3. **See the safety net.** `/history` lists every task with the files it touched.
-4. **Undo it.** `/undo` reverts the task, and if you change your mind changed your mind? `/redo` brings it back. Nothing is ever lost in either direction.
+4. **Undo it.** `/undo` reverts the task, and `/redo` brings it back. Nothing is ever lost in either direction.
 5. **Come back tomorrow.** `faber --resume` continues the conversation, or just ask *"what did we do last time?"* — it searches past sessions itself.
 
 That loop of task, approve, inspect, revert is the whole trust model. Everything else is detail.
@@ -43,7 +30,9 @@ That loop of task, approve, inspect, revert is the whole trust model. Everything
 
 **It has a map, not just eyes.** The code graph stores call and import *edges*, incrementally updated in milliseconds. One ~50-token query (`trace_path(main, saveUser)` → `main → startServer → handleSignup → saveUser`) replaces reading thousands of tokens of files. `/map main` prints the call tree — the "trace it from main" ritual every programmer does, automated.
 
-**It's honest about money.** Prompt caching marks the stable prefix of every request, so repeat loop iterations pay ~10% for tokens already sent. And after every task you see exactly what happened: `tokens: 31.2k in (78% cached) / 1.9k out · 7 calls`.
+**Every model you can reach, including the coding ones.** Claude through the Anthropic API, your own AWS account, or Microsoft Foundry on Azure. OpenAI through both of its APIs — chat completions and the Responses API that the codex family requires — directly or through your Azure subscription. Plus anything OpenAI-compatible, and local models through Ollama for no key and no cost. Faber reads which endpoint each model needs and routes there itself, so `gpt-5.3-codex` and `claude-opus-5` are both just entries in the same list, priced side by side.
+
+**It's honest about money.** Prompt caching marks the stable prefix of every request, so repeat loop iterations pay ~10% for tokens already sent. Every task is costed and recorded as it runs, so `/usage` is a ledger of what you actually spent rather than an estimate — broken down by time window and by model, with the cheapest option always visible next to the one you're using.
 
 **Nothing is irreversible.** Every task is checkpointed before it touches a file. Undo is undoable. Approvals gate both edits *and* shell commands. Rejecting a change tells the model to change course, not retry.
 
@@ -53,11 +42,43 @@ That loop of task, approve, inspect, revert is the whole trust model. Everything
 
 ## Upgrading from Codewright
 
-Faber is Codewright renamed, after the npm name was taken between building and releasing. Existing projects keep working untouched: an existing `.codewright/` state directory is adopted as-is, so memory, code graph, sessions, and usage history all survive. `CW_*` environment variables still work alongside the canonical `FABER_*` names. New projects get `.faber/`.
+Faber is Codewright renamed, after the npm name was taken between building and releasing. Existing `.codewright/` state directories are adopted automatically; `CW_*` environment variables still work alongside `FABER_*`.
 
 ## Requirements & install
 
-You need Node.js 22.5 or newer. Faber uses Node's built-in SQLite, so there are no native dependencies to compile and installs don't fail on a missing toolchain. The only runtime dependencies are two small pure-JS packages.
+Faber needs **Node.js 22.5 or newer**. It uses Node's built-in SQLite, so there are no native dependencies to compile and installs don't fail on a missing toolchain. The only runtime dependencies are two small pure-JS packages.
+
+Check your version:
+
+```bash
+node --version
+```
+
+If it prints `v22.5.0` or higher, skip ahead to Install.
+
+### Installing Node.js
+
+The recommended way is **nvm**, which lets you switch versions per project without touching your system:
+
+```bash
+# macOS / Linux
+curl -o- https://raw.githubusercontent.com/nvm-sh/nvm/v0.40.1/install.sh | bash
+# restart your terminal, or: source ~/.zshrc
+nvm install 22
+nvm use 22
+```
+
+Alternatives:
+
+```bash
+brew install node              # macOS, Homebrew
+winget install OpenJS.NodeJS   # Windows
+sudo apt install nodejs npm    # Debian/Ubuntu — often ships an older version; prefer nvm
+```
+
+Or download an installer from [nodejs.org](https://nodejs.org). Already on Node but below 22.5? `nvm install 22 && nvm use 22`, or `brew upgrade node`.
+
+### Install Faber
 
 ```bash
 npm install -g faberwright
@@ -113,6 +134,7 @@ Setup is skipped entirely when there's no terminal attached, so scripts and CI n
 | **Streaming agent loop** | Text renders as generated, with a live heartbeat (`✳ Working… 14s`) that never interleaves with output and ends in `✳ Worked for 14s`. Plan → tool → observe → adjust, until done. Hard iteration cap. |
 | **Code graph** | Symbols *and* call/import edges, incrementally maintained (only changed files re-parse). Agent tools: `who_calls` (blast radius), `calls_from` (dependencies), `trace_path` (workflow chain). A compact repo map of the most-connected symbols orients every task. Edges are static hints — dynamic dispatch/DI/events aren't captured; the agent reads code where precision matters. |
 | **Approval by default** | Arrow-key menu on every file edit (colored diff) and every shell command. `--auto` / `/auto` / `FABER_APPROVAL=auto` opts into autonomy. |
+| **Two OpenAI APIs** | Chat completions and the Responses API, chosen per model from the endpoint each one publishes. The codex family works without configuration. |
 | **Guided setup** | First run walks through vendor, route, credential and model, then remembers it. Later launches verify the setup can reach a model before opening the prompt. Nothing is saved until setup finishes, so an interrupted run leaves no half-configured state. |
 | **Credentials** | Keys live in `~/.faber/credentials.json`, owner-only, outside every repository. Faber checks that what you paste looks like a key before storing it, hides it as you type, and never prints more than a masked fragment. Environment variables keep working and take precedence. |
 | **Interactive choices** | Genuinely ambiguous request? The agent presents 2–4 options plus "Chat more about this instead" before writing code. |
@@ -137,22 +159,26 @@ Faber separates three choices, so you can change one without redoing the others:
 |---|---|---|
 | **Vendor** | who makes the model | `/route` |
 | **Route** | how you reach it and who owns auth | `/route` |
-| **Model** | which model on that route | `/model` |
+| **Model** | which model on that route | `/model` (searchable model options) |
 
-Routes available today: **Anthropic API**, **Amazon Bedrock**, **OpenAI API**, **Ollama** (local, no key and no cost), and any **OpenAI-compatible endpoint** (OpenRouter, Groq, Together, vLLM, a gateway). Google Vertex is defined but not yet wired up — `/route` says so rather than failing at request time.
+Routes available today: **Anthropic API**, **Amazon Bedrock**, **Microsoft Foundry**, **OpenAI API**, **Azure OpenAI**, **Ollama** (local, no key and no cost), and any **OpenAI-compatible endpoint** (OpenRouter, Groq, Together, vLLM, a gateway). Google Vertex is defined but not yet wired up, and `/route` says so rather than failing at request time.
+
+On OpenAI, Faber speaks both APIs. Chat completions for most models, and the **Responses API** for the ones that require it, which includes the codex family — the coding-tuned models a coding agent actually wants. You don't choose: each model's endpoint is recorded in the price dataset Faber already downloads, so `gpt-5.3-codex` routes to `/v1/responses` and `gpt-5.5` to `/v1/chat/completions` automatically. If a model is too new to appear in that dataset and the API says it belongs elsewhere, Faber retries on the endpoint it names rather than failing.
 
 ### Amazon Bedrock
 
-Faber authenticates two ways, and tries them in this order.
+Setup asks how you want to authenticate, because the choice affects who gets billed.
 
-**With an IAM role, which needs no key at all.** In SageMaker Studio, on EC2, in ECS or Lambda, or on a laptop where you've run `aws configure`, Faber finds your AWS credentials the same way the SDKs do and signs each request with SigV4. Pick Amazon Bedrock during setup, give it a region, and that's the whole configuration. The signing is implemented directly against Node's crypto module rather than pulling in the AWS SDK, so the zero-dependency install still holds, and it's verified against the signature AWS publishes for its own worked example.
+**AWS credentials (IAM role)** needs no key at all. In SageMaker Studio, on EC2, in ECS or Lambda, or on a laptop where you've run `aws configure`, Faber finds your credentials the same way the SDKs do and signs each request with SigV4. The region comes from `AWS_REGION` or `~/.aws/config` when it's there, so usually nothing is asked at all. Signing is implemented directly against Node's crypto module rather than pulling in the AWS SDK, and is verified against the signature AWS publishes for its own worked example.
 
-**With a Bedrock API key**, if you'd rather use one:
+**A Bedrock API key** bills through that key instead:
 
 ```bash
 export BEDROCK_API_KEY=...
 ```
 
+Either path must complete: pick the role with no credentials present, or the key without entering one, and setup saves nothing and starts over next time.
+
 Model ids on Bedrock differ by region and deployment, so pin them per alias in your profile instead of relying on the built-in names:
 
 ```json
@@ -161,19 +187,66 @@ Model ids on Bedrock differ by region and deployment, so pin them per alias in y
   "apiKeyEnv": "BEDROCK_API_KEY" }
 ```
 
+### Claude on Azure (Microsoft Foundry)
+
+Claude has been generally available in Microsoft Foundry since June 2026, hosted on Azure with your organisation's own authentication, billing and governance — usage appears on the Azure invoice and can count toward a Microsoft Azure Consumption Commitment.
+
+It serves the same Messages API as the direct route, so for Faber this is a base URL and an auth header rather than a new protocol: prompt caching, extended thinking and tool streaming all work unchanged. Setup asks for your resource name and takes either a subscription key or a token minted from Entra ID, recognising which you gave it.
+
+```bash
+export AZURE_FOUNDRY_API_KEY=...
+```
+
+A Foundry resource is separate from an Azure OpenAI one and has its own key, so the two never share a credential.
+
+### Azure OpenAI
+
+The answer for anyone who wants OpenAI's coding models billed through their employer rather than a personal card: AWS doesn't host OpenAI models, so Bedrock isn't the route for them — Azure is.
+
+Setup asks for your resource name rather than a URL, since that's the part people know from the portal, and builds the endpoint from it. Azure addresses **deployments** rather than model ids: you call `my-codex-deployment`, a name someone in your organisation chose, and the deployment decides which model runs. Faber lists the deployments your subscription has created and shows the model behind each one.
+
+```bash
+export AZURE_OPENAI_API_KEY=...
+```
+
 ### Costs
 
-`/usage` shows real dollars without any configuration. Prices come from the best source available, in this order: whatever you set explicitly, then the provider's own published rates (OpenRouter publishes per-token prices including cache reads and writes, and needs no key for it), then a community dataset covering everyone else, then a small table built into Faber so it still works offline. Anthropic and OpenAI don't publish prices through their APIs at all, which is why the last two exist.
+`/usage` is a ledger, not an estimate. Every task's cost is worked out and written down when the task runs, at the rates in effect then, and never recalculated. If a vendor raises prices next month, last month's tasks still show what they actually cost.
+
+`/usage` breaks spend down across seven rolling windows — today, 7 days, 14 days, 30 days, 3 months, 6 months, all time — each showing tasks, tokens, cache rate, cost and savings, with a per-model table underneath showing where the money actually goes.
+
+Windows are rolling rather than calendar, so "last 30 days" always means thirty days instead of resetting to one on the first of the month. All seven are shown even when they hold identical numbers: a missing row would read as "no data" when it actually means "nothing new since," and that distinction is the whole point for someone coming back after a break.
+
+The two columns nobody can interpret unaided are defined in the panel itself. **Cached** is the share of input served from a cache rather than billed at full price. **Saved** is the counterfactual: what those same tasks would have cost without prompt caching. The by-model table is the actionable part, since switching routine work to a cheaper model is usually the largest saving available.
+
+**Where prices come from**, best source first: whatever you set explicitly, then the provider's own published rates (OpenRouter publishes per-token prices including cache reads and writes, and needs no key for it), then a community dataset covering everyone else, then a small table built into Faber so it works offline. Anthropic and OpenAI don't publish prices through their APIs at all, which is why the last two exist.
+
+Keeping those rates current matters more than it sounds, precisely because costs are frozen when recorded: a stale table would bake a wrong number into your history permanently. So Faber fetches prices during setup and re-checks on every launch with a conditional request. When nothing has changed the server answers `304` with no body — about 70ms in the background — so there's no window where an out-of-date rate can enter your records. The full download happens only when the list actually changes, and after a failed attempt Faber waits a day before retrying so an offline machine isn't making a doomed request on every start.
+
+Turn the automatic refresh off with `FABER_AUTO_PRICES=0` or `"autoRefreshPrices": false` in your profile. This is the only network request Faber makes that isn't an inference call; it fetches a public price list and sends nothing about you.
+
+Costs use each model's own input, output, cache-read and cache-write rates rather than a flat multiplier, and cloud model ids like `us.anthropic.claude-sonnet-5` normalise onto the same entry as the direct one. `FABER_PRICE_IN` and `FABER_PRICE_OUT`, or `priceIn` and `priceOut` in a profile, override everything. A model with no known price shows a dash rather than a guess.
+
+**What gets recorded.** One row per task in `<project>/.faber/usage.db`:
 
 ```
-faber> /usage --refresh-prices     # pull current rates now
+ts           1785979475047     when it ran
+input        27000             fresh input tokens
+cache_read   46000             served from cache
+cache_write  500               stored into the cache for reuse
+output       3600              generated
+calls        3                 API round-trips inside that task
+model        gpt-5.3-codex     which model ran it
+cost         0.0412            dollars, frozen at run time
+saved        0.0231            what caching avoided
 ```
 
-Keeping those rates current matters more than it might sound, because a task's cost is written down when the task runs and never recalculated. If a vendor raises prices next month, last month's tasks still show what they actually cost. That's the point of a ledger. But it also means a stale price table would bake a wrong number into your history permanently, so Faber fetches prices once during setup and re-checks on every launch using a conditional request. When nothing has changed the server answers with a 304 and no body, which costs about 70ms in the background, so there's no window where an out-of-date rate can slip into your records. The full download only happens when the price list actually changes, and after a failed attempt Faber waits a day before trying again so an offline machine isn't making a doomed request every time you start.
+<img width="636" height="388" alt="Screenshot 2026-08-10 at 12 25 57 AM" src="https://github.com/user-attachments/assets/33ba06ce-69ad-4afe-afcc-6119a897e67a" />
+
 
-You can turn the automatic refresh off with `FABER_AUTO_PRICES=0` or `"autoRefreshPrices": false` in your profile, in which case Faber falls back to its built-in rates and mentions at startup when they're getting old. This is the only network request Faber makes that isn't an inference call. It fetches a public price list and sends nothing about you.
+Counters and a timestamp. No prompts, no code, no file contents. Around 80 bytes a row, so a year of heavy use is roughly a megabyte, and nothing is ever pruned.
 
-Costs use each model's own input, output, cache-read and cache-write rates rather than a flat multiplier, and cloud model ids like `us.anthropic.claude-sonnet-5` normalize onto the same entry as the direct one. Setting `FABER_PRICE_IN` and `FABER_PRICE_OUT`, or `priceIn` and `priceOut` in a profile, overrides everything. A model with no known price shows a dash rather than a guess.
+Keeping the raw rows rather than rolling them into running totals is deliberate: any question you think of later can still be answered about the past. Spend for a particular month, which model a given week ran on, cost per task before and after a prompt change. It's a plain SQLite file, so `sqlite3 .faber/usage.db` will answer anything Faber doesn't print — including an expense report of your own shape.
 
 Settings live in `~/.faber/settings.json` as named **profiles**:
 
@@ -196,10 +269,10 @@ Settings resolve in this order, highest first: environment variables, then a pro
 ```
 /setup              run setup again (vendor, route, credential, model)
 /route              choose a vendor and route
-/model [alias]      switch model; lists what your key can actually use
+/model [id]         switch model; lists what your key can use, with prices
 /key [set|rm]       show, save or remove an API key
 /profile [name]     list or switch saved profiles
-/usage              tokens, cost and cache savings (--refresh-prices)
+/usage              cost ledger by time window and model (--refresh-prices)
 /index              rebuild the code graph (symbols + call edges)
 /map <symbol>       print the call tree from any entry point
 /memory [archived]  long-term memories (+ file notes)
@@ -233,15 +306,17 @@ Flags: `faber [task] [--workspace|-w <dir>] [--resume] [--ask|--auto] [--version
 | `FABER_ROUTE`, `FABER_REGION` | route id and region, overriding the profile |
 | `FABER_AUTO_PRICES` | `0` disables the background price refresh |
 | `BEDROCK_API_KEY` | Bedrock, when you'd rather use a key than an IAM role |
+| `AZURE_OPENAI_API_KEY` | Azure OpenAI, for GPT deployments in your subscription |
+| `AZURE_FOUNDRY_API_KEY` | Microsoft Foundry, for Claude on Azure (a separate resource) |
 | `AWS_ACCESS_KEY_ID` etc. | picked up automatically for Bedrock's SigV4 signing |
 
 Faber keeps three files. `~/.faber/settings.json` holds your profiles, which is the route, model and which environment variable a credential comes from. `~/.faber/credentials.json` holds the keys themselves, owner-only and outside every repository. A project can override the profile with its own `.faber/config.json`, which is useful when one repo should use a cheaper model than the rest.
 
 Commit protection happens on its own. When Faber starts inside a git repo it writes `.faber/` into `.git/info/exclude`, a local ignore that produces no diff and is never committed, so project state can't reach GitHub even if you forget your `.gitignore`. If `.faber/` was already committed at some point in the past, you get a loud warning with the exact `git rm --cached` command to fix it. This matters because sessions and checkpoints can contain the contents of files the agent read. If teammates will use Faber too, add `.faber/` to the shared `.gitignore` so they're covered from their first run.
 
-## Failure-mode matrix
+## What happens when things go wrong
 
-| Failure | Behavior |
+| Situation | What Faber does |
 |---|---|
 | API 429/5xx/network drop | retry with backoff+jitter; Retry-After honored; clear fatal after N attempts |
 | Bad API key | immediate fatal naming the env var to set |
@@ -266,7 +341,7 @@ npm test          # offline test suite, no API key needed
 node selftest.mjs # installation self-check + live agent verification (report file to share)
 ```
 
-The suite deliberately covers the awkward cases rather than the easy ones: undo and redo round-trips, checkpoint ids colliding within the same millisecond, session files torn mid-write, cyclic call graphs, surgical edits through CRLF and emoji, cancellation mid-stream, steering messages keeping the API's role alternation valid, paste markers split across stream chunks, AWS signatures checked against the vector AWS publishes, credential files landing with owner-only permissions, and a recorded cost staying put when prices later change. Several tests drive the real agent loop against a mock streaming server, and one drives the actual CLI binary.
+The suite deliberately covers the awkward cases rather than the easy ones: undo and redo round-trips, checkpoint ids colliding within the same millisecond, session files torn mid-write, cyclic call graphs, surgical edits through CRLF and emoji, cancellation mid-stream, steering messages keeping the API's role alternation valid, paste markers split across stream chunks, AWS signatures checked against the vector AWS publishes, credential files landing with owner-only permissions, a recorded cost staying put when prices later change, Responses-API tool calls assembled from their argument deltas, and usage windows that put a 45-day-old task in "last 3 months" but not "last 30 days". Several tests drive the real agent loop against a mock streaming server, and one drives the actual CLI binary.
 
 CI runs on Ubuntu, macOS and Windows across Node 22 and 24: tests, build, and CLI smoke on every push.
 
@@ -277,18 +352,21 @@ CLI/REPL (index.ts)   streaming render · arrow-key approvals · steering captur
    │
 Agent loop (agent.ts) recall memory + repo map → [LLM ⇄ tools] → verify → summarize
    │                  doom-loop breaker · iteration cap · compaction · session log · steering drain
-   ├─ LLM (llm.ts)            Anthropic + OpenAI-compatible · SSE streaming · prompt caching · usage · retry
+   ├─ LLM (llm.ts)            three wires: Anthropic · OpenAI chat · OpenAI Responses · SSE · caching · retry
+   ├─ Routes (routes.ts)      vendor → route → model · SigV4 for Bedrock (sigv4.ts) · live model discovery
+   ├─ Pricing (pricing.ts)    per-model rates, modes and endpoints · conditional refresh · frozen at spend
    ├─ Tools (tools/)          validated dispatch · mutations staged as diffs · shell gated by approval
    ├─ Graph (indexer.ts)      symbols + call/import edges · incremental · who_calls / trace_path / map
    ├─ Memory (memory/)        shortTerm (window+compaction) · longTerm (SQLite+FTS) · sessions (JSONL)
    └─ Checkpoints             snapshot-before-write · /history · reversible restore
 
-All state in <repo>/.faber/   (memory.db, index.db, sessions/, checkpoints/)
+Per project  <repo>/.faber/    memory.db · index.db · usage.db · sessions/ · checkpoints/
+Per machine  ~/.faber/          settings.json (profiles) · credentials.json (0600) · cache/
 ```
 
 ## Roadmap
 
-Google Vertex is defined but not yet wired up, since its OAuth flow is a bigger piece than Bedrock turned out to be. Beyond that: tree-sitter for compiler-grade graph edges, evicting stale tool results from long conversations, redacting secrets in session logs, team-shared project settings that can live in a repo, embedding-based recall, a branch-per-task git mode, and a VS Code extension built on this core.
+Google Vertex is defined but not yet wired up, since its OAuth flow is a bigger piece than Bedrock turned out to be. Beyond that: tree-sitter for compiler-grade graph edges, evicting stale tool results from long conversations, redacting secrets in session logs, team-shared project settings that can live in a repo, embedding-based recall, a branch-per-task git mode, a `/usage --all` view comparing every project on the machine, and a VS Code extension built on this core.
 
 ## License
 

package/dist/agent.js

@@ -81,6 +81,17 @@ export class Agent {
         this.model = id;
         this.llm.setModel(id);
     }
+    /**
+     * Adopt a new configuration in the running session, after /setup or /route
+     * changed the route. Without this the session keeps talking to the old
+     * provider while the settings file says otherwise, so /model would list
+     * models for a route the user thought they had left.
+     */
+    reconfigure(next) {
+        this.config = next;
+        this.model = next.model;
+        this.llm = new LLMClient(next);
+    }
     steer(text) {
         const t = text.trim();
         if (t)

package/dist/commands.js

@@ -0,0 +1,35 @@
+/**
+ * Deciding whether a line is a command.
+ *
+ * Kept in its own module because index.ts starts the CLI when imported, so a
+ * test that reaches for this function would otherwise boot the whole program
+ * and sit at a prompt forever.
+ */
+/**
+ * How many arguments each command takes. Anything with more is prose.
+ *
+ * The old rule was "starts with a slash", which read only the first word — so
+ * "/undo and /redo how does it work?" reverted the user's files while they
+ * were asking a question about them. A command has to match the WHOLE line.
+ */
+const COMMAND_ARITY = {
+    "/help": 0, "/exit": 0, "/quit": 0, "/undo": 0, "/redo": 0, "/clear": 0,
+    "/compact": 0, "/sessions": 0, "/history": 0, "/index": 0, "/setup": 0,
+    "/route": 0, "/ask": 0, "/auto": 0, "/verbose": 0, "/concise": 0,
+    "/usage": 1, // --refresh-prices
+    "/model": 1, // an id, --save or --refresh
+    "/profile": 1, // a profile name
+    "/map": 1, "/restore": 1, "/forget": 1, "/archive": 1, "/unarchive": 1,
+    "/prune": 1, "/memory": 1,
+    "/key": 2, // set|rm plus a variable name
+};
+export function looksLikeCommand(line) {
+    // Trim first: a pasted or indented line is still a command.
+    const parts = line.trim().split(/\s+/);
+    if (!parts[0]?.startsWith("/"))
+        return false;
+    const arity = COMMAND_ARITY[parts[0].toLowerCase()];
+    if (arity === undefined)
+        return false; // unknown: let /help catch it
+    return parts.length - 1 <= arity;
+}

package/dist/index.js

@@ -38,12 +38,13 @@ import { Composer } from "./editor.js";
 import { StatusLine } from "./status.js";
 import { renderMarkdown, StreamRenderer } from "./markdown.js";
 import { renderUsagePanel, UsageLedger } from "./usage.js";
+import { looksLikeCommand } from "./commands.js";
 import { ROUTES, getRoute, describeModel, resolveModel, vendors, baseUrlFor, DEFAULT_REGION } from "./routes.js";
 import { loadSettings, saveSettings, updateActive, settingsPath } from "./settings.js";
 import { needsOnboarding, interactive, runOnboarding, reportSetup, setupComplete } from "./onboard.js";
 import { saveCredential, deleteCredential, listCredentialNames, getCredential, maskCredential, credentialsPath, resolveCredential, looksLikeKey, } from "./credentials.js";
 import { readCache, writeCache, clearCache, buildPicker } from "./models.js";
-import { refreshPrices, priceFor } from "./pricing.js";
+import { refreshPrices, priceFor, readPriceCache } from "./pricing.js";
 /** Version comes from package.json — one source of truth for banner and --version. */
 const VERSION = (() => {
     try {
@@ -60,6 +61,18 @@ function renderDiff(diff) {
             : l.startsWith("@@") ? pc.cyan(l)
                 : pc.dim(l)).join("\n");
 }
+/**
+ * Is this line a command, or a question that happens to mention one?
+ *
+ * Matching on the first word alone meant "/undo and /redo how does it work?"
+ * ran /undo and reverted the user's files. A destructive command must be the
+ * whole line — anything trailing means the person is talking, not commanding.
+ */
+const NO_ARG_COMMANDS = new Set([
+    "/undo", "/redo", "/history", "/clear", "/compact", "/sessions", "/help",
+    "/exit", "/quit", "/index", "/memory", "/ask", "/auto", "/verbose",
+    "/concise", "/setup", "/route",
+]);
 async function main() {
     const argv = process.argv.slice(2);
     const flags = new Set(argv.filter((a) => a.startsWith("-")));
@@ -396,6 +409,15 @@ async function main() {
                     console.log(pc.dim("  /model --save   make it the profile default"));
                     break;
                 }
+                // With no price data at all — first run, or the cache was discarded
+                // because an older Faber wrote it — wait for the fetch rather than
+                // rendering a menu that says "price unknown" for everything. The
+                // background refresh is fine when we already have rates to show.
+                if (!readPriceCache()) {
+                    process.stdout.write(pc.dim("  fetching prices… "));
+                    await refreshPrices(undefined, { baseUrl: config.baseUrl });
+                    process.stdout.write("\r\x1b[2K");
+                }
                 // Ask the provider what this key can actually use; cached for a day.
                 if (args[0] === "--refresh")
                     clearCache(route.id);
@@ -412,8 +434,15 @@ async function main() {
                     console.log(`No model list available for ${route.label}. Set one with: /model <id>`);
                     break;
                 }
+                // Show the rate here too. /model is where people switch models to save
+                // money, so hiding the price is exactly backwards.
                 const width = Math.min(34, Math.max(...entries.map((e) => e.label.length)) + 2);
-                const labels = entries.map((e) => `${e.label.padEnd(width)}${pc.dim(e.blurb)}${e.live ? pc.dim("  ·live") : ""}`);
+                const labels = entries.map((e) => {
+                    const id = resolveModel(e.value, route, config.modelPins);
+                    const p = priceFor(id, { in: config.priceIn, out: config.priceOut });
+                    const cost = p ? `$${p.in}/$${p.out} per Mtok` : "price unknown";
+                    return `${e.label.padEnd(width)}${pc.dim(cost.padEnd(22))}${pc.dim(e.blurb)}`;
+                });
                 const curIdx = entries.findIndex((e) => e.value === agent.model || resolveModel(e.value, route, config.modelPins) === agent.model);
                 const pick = await select(rl, "Select model (this session)", labels, curIdx < 0 ? 0 : curIdx);
                 const chosen = entries[pick];
@@ -464,7 +493,14 @@ async function main() {
             case "/setup": {
                 const setup = await runOnboarding(rl);
                 reportSetup(setup);
-                console.log(pc.dim("  restart faber to apply"));
+                if (!setup.aborted) {
+                    // Apply in this session. Telling the user to restart left the
+                    // running agent on the old route, so /model would then list models
+                    // for the provider they had just switched away from.
+                    config = loadConfig(config.workspace);
+                    agent.reconfigure(config);
+                    console.log(pc.dim(`  now using ${describeModel(config.model, getRoute(config.route) ?? ROUTES[0], config.modelPins)} on ${getRoute(config.route)?.label}`));
+                }
                 break;
             }
             case "/route": {
@@ -506,7 +542,9 @@ async function main() {
                 if (chosen.aliasesArePinned) {
                     console.log(pc.dim("  model ids differ on this route — set one with: /model <id>"));
                 }
-                console.log(pc.dim("  restart faber to apply"));
+                config = loadConfig(config.workspace);
+                agent.reconfigure(config);
+                console.log(pc.dim(`  now on ${getRoute(config.route)?.label}`));
                 break;
             }
             case "/profile": {
@@ -527,7 +565,9 @@ async function main() {
                 }
                 st.activeProfile = args[0];
                 saveSettings(st);
-                console.log(`Active profile: ${args[0]}. Restart faber to apply.`);
+                config = loadConfig(config.workspace);
+                agent.reconfigure(config);
+                console.log(`Active profile: ${args[0]} — ${getRoute(config.route)?.label}, ${config.model}.`);
                 break;
             }
             case "/usage": {
@@ -611,7 +651,7 @@ async function main() {
             }
             if (!line)
                 continue;
-            if (line.startsWith("/")) {
+            if (line.startsWith("/") && looksLikeCommand(line)) {
                 if (!(await command(line)))
                     break;
                 continue;
@@ -626,6 +666,13 @@ async function main() {
     }
 }
 const HELP = `
+  /setup              set up again: vendor, route, credential, model
+  /route              choose a vendor and how to reach it
+  /model [id]         switch model; lists what your key can use, with prices
+  /key [set|rm]       show, save or remove an API key (~/.faber, readable only by you)
+  /profile [name]     list or switch saved profiles
+  /usage              cost ledger by time window and model (--refresh-prices)
+  /verbose | /concise full-depth answers, or short ones (default concise)
   /index              rebuild the code graph (symbols + call edges)
   /map <symbol>       print the call tree from any entry point (e.g. /map main)
   /memory             show active long-term memories (+ file notes)