faberwright 0.4.1 → 0.4.3

package/README.md

@@ -5,7 +5,7 @@
 *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" />
+<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" />
@@ -21,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.
@@ -30,7 +30,7 @@ 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.
 
-**Every model you can reach, including the coding ones.** Claude through the Anthropic API or your own AWS account, OpenAI through both of its APIs — chat completions and the Responses API that the codex family requires — 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.
+**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.
 
@@ -40,9 +40,45 @@ That loop of task, approve, inspect, revert is the whole trust model. Everything
 
 **You can steer it mid-flight.** See it going the wrong way? Just type `use TypeScript, not JavaScript` — and your guidance is injected at the next loop iteration. No cancelling, no wasted tokens.
 
+## Upgrading from Codewright
+
+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
@@ -93,10 +129,18 @@ Setup is skipped entirely when there's no terminal attached, so scripts and CI n
 
 ## Features
 
-| Feature|Description |
+| | |
 |---|---|
 | **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. |
+| **Mid-task steering** | Type while it works; guidance is injected at the next loop boundary. If the model finishes while steering is queued, the task continues instead. Steering markers carry a per-task nonce, so hostile file contents can't impersonate you. |
+| **Paste as chips** | Raw-mode composer: pasting a 50-line block renders only a chip — `[pasted #1 +50 lines]` — never the code itself, while the full text is expanded into the message on Enter. Paste the same block again to expand it visibly. Paste, type, paste again: one submission. Full line editing: arrows, Home/End, forward-delete, Ctrl-A/E/K/U, Up/Down history; long drafts wrap across rows with exact cursor tracking — backspace and arrows travel across wrap boundaries. Chips are atomic — one arrow step, one backspace.  Works at the prompt and while steering. |
+| **Reversible history** | `/history` lists tasks with files touched; `/restore <id>` jumps anywhere; `/undo` / `/redo` — restores are never destructive. |
 | **Git-aware** | Warns about uncommitted changes at startup. Optional `FABER_GIT=commit`: one commit per completed *task* (never per edit). The agent never commits by default. |
 | **Two-layer memory** | Short-term: token-budgeted window, auto-summarized past 60k (tool pairs never split). Long-term: SQLite+FTS5 facts/decisions/gotchas + per-file notes, with full lifecycle (`/forget`, `/archive`, `/prune`). |
 | **Sessions** | Crash-safe JSONL transcripts; `--resume`; last-session digest injected at startup; `recall_sessions` keyword search across history. |
@@ -106,11 +150,6 @@ Setup is skipped entirely when there's no terminal attached, so scripts and CI n
 | **Usage dashboard** | `/usage` shows a persistent ledger: tasks, tokens, cache rate, cost, and cache *savings* — for this session, today, and all time, plus totals across every project on the machine. Costs use each model's own rates, including its exact cache read/write prices, so a history spanning a model switch stays accurate. Prices ship built in and update with `/usage --refresh-prices`. Records live in `.faber/usage.db` per project and survive restarts. |
 | **Error recovery** | Transient API errors: backoff + jitter, honors Retry-After. Tool errors return to the model to self-correct. Identical call failing twice → warning; three times → clean abort. Ctrl-C aborts streams *and* running commands; checkpoints survive. |
 | **Safety rails** | Symlink-resolved path jail, shell denylist, timeouts, output truncation, atomic writes (temp+rename), stale-edit guard. Guardrails, not a sandbox — use a container for untrusted code. |
-| **Approval by default** | Arrow-key menu on every file edit (colored diff) and every shell command. `--auto` / `/auto` / `FABER_APPROVAL=auto` opts into autonomy. |
-| **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. |
-| **Mid-task steering** | Type while it works; guidance is injected at the next loop boundary. If the model finishes while steering is queued, the task continues instead. Steering markers carry a per-task nonce, so hostile file contents can't impersonate you. |
-| **Reversible history** | `/history` lists tasks with files touched; `/restore <id>` jumps anywhere; `/undo` / `/redo` — restores are never destructive. |
 
 ## Vendors, routes, and models
 
@@ -122,22 +161,24 @@ Faber separates three choices, so you can change one without redoing the others:
 | **Route** | how you reach it and who owns auth | `/route` |
 | **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, and `/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
@@ -146,6 +187,28 @@ 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` 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.
@@ -177,9 +240,8 @@ model        gpt-5.3-codex     which model ran it
 cost         0.0412            dollars, frozen at run time
 saved        0.0231            what caching avoided
 ```
-**Cost metrics `/usage`:
 
-<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" />
+<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" />
 
 
 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.
@@ -244,6 +306,8 @@ 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.

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,6 +38,7 @@ 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";
@@ -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("-")));
@@ -638,7 +651,7 @@ async function main() {
             }
             if (!line)
                 continue;
-            if (line.startsWith("/")) {
+            if (line.startsWith("/") && looksLikeCommand(line)) {
                 if (!(await command(line)))
                     break;
                 continue;
@@ -653,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)

package/dist/llm.js

@@ -7,6 +7,8 @@ const RETRYABLE = new Set([408, 409, 429, 500, 502, 503, 504, 529]);
  * is not a useful thing to tell someone whose key demonstrably works — the
  * status code or error usually says exactly what went wrong.
  */
+/** Azure pins the API surface by date; this one covers tools and streaming. */
+export const AZURE_API_VERSION = "2024-10-21";
 let lastListError;
 export function lastModelListError() { return lastListError; }
 /** AWS credentials discovered once per process for SigV4 routes. */
@@ -45,12 +47,20 @@ export class LLMClient {
      * models route, which says nothing about the key and must not block setup.
      */
     async verifyKey() {
+        if (this.config.route === "bedrock") {
+            // The mantle endpoint has no listing to probe, so treat a working
+            // credential discovery as sufficient; a bad one fails on first use.
+            return (await this.listBedrockModels()).length ? "ok" : "unreachable";
+        }
         const anthropic = this.config.provider === "anthropic";
         const url = anthropic ? `${this.config.baseUrl}/v1/models?limit=1`
             : `${this.config.baseUrl}/models`;
+        const auth = await this.authHeaders(url, "", "GET");
         const headers = anthropic
-            ? { "x-api-key": this.config.apiKey, "anthropic-version": "2023-06-01" }
-            : { authorization: `Bearer ${this.config.apiKey}` };
+            ? { ...auth, "anthropic-version": "2023-06-01" }
+            : this.config.route === "azure-openai"
+                ? { "api-key": this.config.apiKey ?? "" }
+                : (this.config.apiKey ? { authorization: `Bearer ${this.config.apiKey}` } : auth);
         try {
             const ctl = new AbortController();
             const timer = setTimeout(() => ctl.abort(), 8000);
@@ -64,15 +74,87 @@ export class LLMClient {
             return "unreachable";
         }
     }
+    /**
+     * Bedrock has no Messages-style listing: the mantle endpoint serves
+     * /v1/messages but returns 404 for /v1/models. AWS's own ListFoundationModels
+     * is the catalogue, on a different host and signed as a normal AWS call.
+     */
+    async listBedrockModels() {
+        const region = this.config.region ?? "us-east-1";
+        const url = this.config.bedrockCatalogUrl
+            ?? `https://bedrock.${region}.amazonaws.com/foundation-models`;
+        try {
+            const auth = await this.authHeaders(url, "", "GET");
+            const ctl = new AbortController();
+            const timer = setTimeout(() => ctl.abort(), 8000);
+            const res = await fetch(url, { headers: auth, signal: ctl.signal });
+            clearTimeout(timer);
+            if (!res.ok) {
+                lastListError = `HTTP ${res.status} from ListFoundationModels`;
+                return [];
+            }
+            const body = await res.json();
+            return (body.modelSummaries ?? [])
+                .filter((m) => typeof m.modelId === "string"
+                && /anthropic/i.test(m.providerName ?? m.modelId)
+                // skip image and embedding variants; we only run text
+                && (!m.outputModalities || m.outputModalities.includes("TEXT")))
+                .map((m) => ({ id: m.modelId, name: m.modelName }));
+        }
+        catch (e) {
+            lastListError = e instanceof Error ? e.message : String(e);
+            return [];
+        }
+    }
+    /**
+     * Azure exposes the deployments a subscription has created, not OpenAI's
+     * catalogue: you address `my-gpt5-codex`, a name someone chose, and the
+     * underlying model is a property of it.
+     */
+    async listAzureDeployments() {
+        const base = this.config.baseUrl.replace(/\/openai\/deployments\/[^/]+\/?$/, "");
+        const url = `${base}/openai/deployments?api-version=${AZURE_API_VERSION}`;
+        try {
+            const ctl = new AbortController();
+            const timer = setTimeout(() => ctl.abort(), 8000);
+            const res = await fetch(url, {
+                headers: { "api-key": this.config.apiKey ?? "" }, signal: ctl.signal,
+            });
+            clearTimeout(timer);
+            if (!res.ok) {
+                lastListError = `HTTP ${res.status} from ${url}`;
+                return [];
+            }
+            const body = await res.json();
+            return (body.data ?? [])
+                .filter((d) => typeof d.id === "string")
+                // the deployment name is what you call; the model is what it runs
+                .map((d) => ({ id: d.id, name: d.model }));
+        }
+        catch (e) {
+            lastListError = e instanceof Error ? e.message : String(e);
+            return [];
+        }
+    }
     async listModels(signal) {
+        if (this.config.route === "bedrock")
+            return this.listBedrockModels();
+        if (this.config.route === "azure-openai")
+            return this.listAzureDeployments();
         lastListError = undefined;
         const anthropic = this.config.provider === "anthropic";
         const url = anthropic
             ? `${this.config.baseUrl}/v1/models?limit=100`
             : `${this.config.baseUrl}/models`;
+        // Sign when the route authenticates with AWS credentials. Sending an
+        // empty x-api-key here failed silently, which left setup with no models
+        // and a default that doesn't exist on Bedrock.
+        const auth = await this.authHeaders(url, "", "GET");
         const headers = anthropic
-            ? { "x-api-key": this.config.apiKey, "anthropic-version": "2023-06-01" }
-            : { authorization: `Bearer ${this.config.apiKey}` };
+            ? { ...auth, "anthropic-version": "2023-06-01" }
+            : this.config.route === "azure-openai"
+                ? { "api-key": this.config.apiKey ?? "" }
+                : (this.config.apiKey ? { authorization: `Bearer ${this.config.apiKey}` } : auth);
         try {
             const ctl = new AbortController();
             const timer = setTimeout(() => ctl.abort(), 6000);
@@ -105,7 +187,14 @@ export class LLMClient {
      * Auth for one request. An API key is a header; AWS credentials mean signing
      * the whole request, which is how an IAM role authenticates with no key.
      */
-    async authHeaders(url, body) {
+    async authHeaders(url, body, method = "POST") {
+        // Foundry authenticates the Azure way: an api-key header, or a bearer
+        // token if one was minted from Entra ID.
+        if (this.config.route === "foundry" && this.config.apiKey) {
+            return /^ey[A-Za-z0-9_-]+\./.test(this.config.apiKey)
+                ? { authorization: `Bearer ${this.config.apiKey}` } // an Entra token
+                : { "api-key": this.config.apiKey };
+        }
         if (this.config.apiKey)
             return { "x-api-key": this.config.apiKey };
         if (this.config.route !== "bedrock")
@@ -118,7 +207,7 @@ export class LLMClient {
                 "or `aws configure`.");
         }
         return signRequest({
-            method: "POST",
+            method,
             url,
             body,
             region: this.config.region ?? "us-east-1",
@@ -256,8 +345,19 @@ export class LLMClient {
                 function: { name: t.name, description: t.description, parameters: t.input_schema },
             }));
         }
-        const res = await this.post(`${this.config.baseUrl}/chat/completions`, {
-            Authorization: `Bearer ${this.config.apiKey}`,
+        // Azure authenticates with api-key rather than a bearer token, and pins
+        // the API version as a query parameter.
+        const azure = this.config.route === "azure-openai";
+        // On Azure the deployment name goes in the path, and the model field in
+        // the body is ignored — the deployment decides which model runs.
+        const chatUrl = azure
+            ? `${this.config.baseUrl}/deployments/${encodeURIComponent(modelOverride ?? this.config.model)}` +
+                `/chat/completions?api-version=${AZURE_API_VERSION}`
+            : `${this.config.baseUrl}/chat/completions`;
+        const res = await this.post(chatUrl, {
+            ...(azure
+                ? { "api-key": this.config.apiKey }
+                : { Authorization: `Bearer ${this.config.apiKey}` }),
             "content-type": "application/json",
         }, body, signal);
         let text = "";

package/dist/onboard.js

@@ -10,6 +10,8 @@ const KEY_SOURCE = {
     ANTHROPIC_API_KEY: "https://console.anthropic.com/settings/keys",
     OPENAI_API_KEY: "https://platform.openai.com/api-keys",
     BEDROCK_API_KEY: "the AWS console (Bedrock → API keys)",
+    AZURE_OPENAI_API_KEY: "the Azure portal (your OpenAI resource → Keys and Endpoint)",
+    AZURE_FOUNDRY_API_KEY: "the Azure portal (your Foundry resource → Keys and Endpoint)",
 };
 export function needsOnboarding() {
     return !hasAnySettingsFile();
@@ -33,8 +35,12 @@ export async function setupComplete(cfg) {
     if (!route.implemented) {
         return { complete: false, missing: `${route.label} isn't wired up yet`, fix: "/route" };
     }
-    if (!cfg.model)
+    // Not merely "is it set": an interrupted prompt used to store control
+    // characters, which are non-empty and so passed every naive check.
+    // eslint-disable-next-line no-control-regex
+    if (!cfg.model || !cfg.model.trim() || /[\x00-\x1f]/.test(cfg.model)) {
         return { complete: false, missing: "no model chosen", fix: "/model" };
+    }
     if (route.needsBaseUrl && !cfg.baseUrl) {
         return { complete: false, missing: "no endpoint URL for this route", fix: "/route" };
     }
@@ -87,6 +93,40 @@ async function readKey(rl, envName, promptText) {
     }
     return key;
 }
+/**
+ * Read a plain answer, treating an interrupt as cancellation.
+ *
+ * A raw readline prompt collects Ctrl-C as the character \x03 rather than
+ * aborting, so pressing it during the region or model question stored control
+ * characters as the answer — and since they aren't empty, every completeness
+ * check passed and the profile was saved as valid.
+ */
+async function askText(rl, prompt) {
+    let raw;
+    try {
+        raw = await rl.question(prompt);
+    }
+    catch {
+        return undefined;
+    }
+    // Ctrl-C is the only thing that means "stop". Everything else that isn't
+    // printable is terminal noise: a paste arrives wrapped in bracketed-paste
+    // markers, so rejecting all control characters made pasting an answer
+    // abort setup — which is exactly what someone does with a resource name.
+    // eslint-disable-next-line no-control-regex
+    if (/[\x03\x04]/.test(raw))
+        return undefined;
+    const cleaned = raw
+        // eslint-disable-next-line no-control-regex
+        .replace(/\x1b\[20[01]~/g, "")
+        // eslint-disable-next-line no-control-regex
+        .replace(/\x1b\[[0-9;]*[A-Za-z~]/g, "")
+        // eslint-disable-next-line no-control-regex
+        .replace(/[\x00-\x1f\x7f]/g, "");
+    return cleaned.trim();
+}
+/** Exposed for tests: paste handling here decides whether setup can finish. */
+export const __askTextForTest = askText;
 /**
  * Walk vendor -> route -> region/endpoint -> model. Returns the profile it
  * saved so the caller can report what still needs doing (e.g. an unset key).
@@ -181,13 +221,42 @@ export async function ensureCredential(rl, route, profile) {
         return {};
     }
     if (route.id === "bedrock") {
-        // Bedrock can sign with an IAM role, so a key may not be needed at all.
+        // Two ways in, and which one you pick can matter for billing: an IAM role
+        // charges through the account that owns it, a Bedrock API key can belong
+        // to a different arrangement entirely. So ask rather than assume, even
+        // when one option is obvious from the environment.
         const { discoverAwsCredentials } = await import("./sigv4.js");
         const aws = await discoverAwsCredentials();
         console.log();
-        console.log(aws
-            ? pc.dim(`  No key needed — signing with AWS credentials from ${aws.source}.`)
-            : pc.yellow(`  No AWS credentials found. Set ${route.keyEnv}, or run where an IAM role is available.`));
+        const how = await select(rl, "How should Faber authenticate with AWS?", [
+            `AWS credentials (IAM role)       ${pc.dim(aws ? `found: ${aws.source}` : "none found here")}`,
+            `Bedrock API key                  ${pc.dim("billed through that key instead")}`,
+        ]);
+        if (how === 0) {
+            if (!aws) {
+                // Nothing to sign with, so setup did not succeed and saves nothing.
+                console.log(pc.yellow("  No AWS credentials on this machine."));
+                console.log(pc.dim("  Run where an IAM role is available (SageMaker, EC2, ECS), or `aws configure`."));
+                return { switchedTo: "quit" };
+            }
+            console.log(pc.dim(`  Signing automatically with your AWS role. No key needed.`));
+            delete profile.apiKeyEnv; // this route authenticates by signing
+            return {};
+        }
+        console.log();
+        console.log("Faber needs a Bedrock API key.");
+        const where = KEY_SOURCE[route.keyEnv];
+        if (where)
+            console.log(pc.dim(`  Get one at ${where}`));
+        const key = await readKey(rl, route.keyEnv, `  ${route.keyEnv} (hidden): `);
+        if (!key) {
+            console.log(pc.yellow("  No key entered — setup not completed, nothing saved."));
+            return { switchedTo: "quit" };
+        }
+        saveCredential(route.keyEnv, key);
+        profile.apiKeyEnv = route.keyEnv;
+        profile.preferStoredKey = true; // an explicit choice beats a role
+        console.log(pc.dim(`  saved (${maskCredential(key)}) — kept on this computer only`));
         return {};
     }
     // No key anywhere: say where to get one, read it hidden, and if they don't
@@ -256,15 +325,6 @@ async function discoverModels(route, profile) {
 async function finish(rl, route, base) {
     const profile = { ...base, route: route.id };
     const activeRoute = route;
-    if (route.needsRegion) {
-        const ans = (await rl.question(`AWS region [${DEFAULT_REGION}]: `)).trim();
-        profile.region = ans || DEFAULT_REGION;
-    }
-    if (route.needsBaseUrl) {
-        const ans = (await rl.question("Base URL of the OpenAI-compatible endpoint: ")).trim();
-        if (ans)
-            profile.baseUrl = ans;
-    }
     if (route.keyEnv) {
         profile.apiKeyEnv = route.keyEnv;
         const outcome = await ensureCredential(rl, activeRoute, profile);
@@ -274,6 +334,51 @@ async function finish(rl, route, base) {
             return { profile, route: activeRoute, aborted: true };
         }
     }
+    if (route.id === "foundry") {
+        // Same question as Azure OpenAI: the resource name is what people know.
+        const res = await askText(rl, "Azure resource name (from your endpoint URL): ");
+        if (res === undefined)
+            return { profile, route: activeRoute, aborted: true };
+        if (res) {
+            profile.baseUrl = /^https?:\/\//.test(res)
+                ? res.replace(/\/+$/, "")
+                : `https://${res}.services.ai.azure.com/anthropic`;
+        }
+    }
+    else if (route.id === "azure-openai") {
+        // Ask for the resource name rather than a URL: it's the part people know
+        // from the portal, and the rest of the endpoint is fixed.
+        const res = await askText(rl, "Azure resource name (from your endpoint URL): ");
+        if (res === undefined)
+            return { profile, route: activeRoute, aborted: true };
+        if (res) {
+            profile.baseUrl = /^https?:\/\//.test(res)
+                ? res.replace(/\/+$/, "")
+                : `https://${res}.openai.azure.com/openai`;
+        }
+    }
+    else if (route.needsBaseUrl) {
+        const ans = await askText(rl, "Base URL of the OpenAI-compatible endpoint: ");
+        if (ans === undefined)
+            return { profile, route: activeRoute, aborted: true };
+        if (ans)
+            profile.baseUrl = ans;
+    }
+    if (route.needsRegion) {
+        // Only ask when the environment hasn't already answered.
+        const { discoverAwsRegion } = await import("./sigv4.js");
+        const found = discoverAwsRegion();
+        if (found) {
+            profile.region = found.region;
+            console.log(pc.dim(`  Region ${found.region} (from ${found.source}) · /route to change`));
+        }
+        else {
+            const ans = await askText(rl, `AWS region [${DEFAULT_REGION}]: `);
+            if (ans === undefined)
+                return { profile, route: activeRoute, aborted: true };
+            profile.region = ans || DEFAULT_REGION;
+        }
+    }
     // Model choice, with real ids and real prices.
     //
     // Aliases like "gpt" or "sonnet" hide what you're actually paying for, and
@@ -329,14 +434,38 @@ async function finish(rl, route, base) {
     }
     else {
         const hint = activeRoute.id === "ollama" ? "qwen2.5-coder" : "";
-        const ans = (await rl.question(`Model id${hint ? ` [${hint}]` : ""}: `)).trim();
+        const ans = await askText(rl, `Model id${hint ? ` [${hint}]` : ""}: `);
+        if (ans === undefined)
+            return { profile, route: activeRoute, aborted: true };
         profile.model = ans || hint || undefined;
     }
+    // Nothing is written unless the result is genuinely usable. Every earlier
+    // exit already returns aborted, but this is the single place that decides,
+    // so a future step can't accidentally save a half-finished profile.
+    const check = await setupComplete({
+        route: profile.route,
+        model: profile.model,
+        baseUrl: profile.baseUrl ?? baseUrlFor(activeRoute, profile.region),
+        apiKey: activeRoute.keyEnv ? credentialSource(activeRoute.keyEnv)?.value : undefined,
+    });
+    if (!check.complete) {
+        console.log();
+        console.log(pc.yellow(`Setup not completed — ${check.missing}.`));
+        console.log(pc.dim("  Nothing was saved. Run faber again to start over."));
+        return { profile, route: activeRoute, aborted: true };
+    }
     const settings = loadSettings();
     settings.profiles[settings.activeProfile] = profile;
     saveSettings(settings);
-    const missingKeyEnv = activeRoute.keyEnv && !credentialSource(activeRoute.keyEnv)
+    // Bedrock signs with an IAM role when one is available, so a missing key is
+    // not "one thing left" — saying so contradicts the line printed moments ago.
+    let missingKeyEnv = activeRoute.keyEnv && !credentialSource(activeRoute.keyEnv)
         ? activeRoute.keyEnv : undefined;
+    if (missingKeyEnv && activeRoute.id === "bedrock") {
+        const { discoverAwsCredentials } = await import("./sigv4.js");
+        if (await discoverAwsCredentials())
+            missingKeyEnv = undefined;
+    }
     return { profile, route: activeRoute, missingKeyEnv };
 }
 /** Summary printed after onboarding, including anything still to be done. */

package/dist/pricing.js

@@ -253,6 +253,21 @@ export async function refreshPrices(url = DATASET_URL, opts = {}) {
  * id, then normalized), then the built-in table. Undefined means "unknown",
  * which the ledger renders as — rather than guessing.
  */
+/**
+ * Azure's US Data Zone deployments bill at 1.1x. Applying it keeps the ledger
+ * honest for teams who chose that deployment for data-residency reasons —
+ * under-reporting spend is the one direction a cost tool must not err in.
+ */
+export const US_DATA_ZONE_MULTIPLIER = 1.1;
+export function scalePrice(p, factor) {
+    const r = (n) => Math.round(n * factor * 1e6) / 1e6;
+    return {
+        ...p,
+        in: r(p.in), out: r(p.out),
+        cacheRead: p.cacheRead === undefined ? undefined : r(p.cacheRead),
+        cacheWrite: p.cacheWrite === undefined ? undefined : r(p.cacheWrite),
+    };
+}
 export function priceFor(modelId, override) {
     if (override?.in && override?.out)
         return { in: override.in, out: override.out };

package/dist/prompt.js

@@ -71,6 +71,14 @@ async function selectRaw(rl, question, options, defaultIndex = 0) {
             stdin.removeListener("data", onData);
             stdin.setRawMode(wasRaw);
             guardFn?.(false);
+            // Drop anything still buffered — typically the Enter that confirmed this
+            // menu. Left in place, readline hands it straight to the next question,
+            // which then returns an empty answer before the user can type a
+            // character: the prompt appears and vanishes in the same instant.
+            try {
+                while (stdin.read() !== null) { /* discard */ }
+            }
+            catch { /* not readable */ }
             rl.resume();
             resolve(result);
         };

package/dist/routes.js

@@ -39,6 +39,24 @@ export const ROUTES = [
         aliasesArePinned: true, // Bedrock model ids differ per region/deployment
         implemented: true,
     },
+    {
+        // Claude hosted on Azure through Microsoft Foundry. It speaks the same
+        // Messages API as the direct route, so this is a base URL and an auth
+        // header rather than a new wire — the migration Microsoft describes as
+        // "swap the base URL and authentication, keep the calls the same".
+        id: "foundry",
+        vendor: "Anthropic",
+        label: "Microsoft Foundry (Azure)",
+        hint: "your Azure subscription owns auth and billing",
+        wire: "anthropic",
+        needsBaseUrl: true,
+        // Its own variable: a Foundry resource is separate from an Azure OpenAI
+        // one, with its own key. Sharing the name meant a key saved for GPT
+        // deployments was offered for Claude, where it cannot work.
+        keyEnv: "AZURE_FOUNDRY_API_KEY",
+        aliasesArePinned: true, // you address a deployment someone named
+        implemented: true,
+    },
     {
         id: "vertex",
         vendor: "Anthropic",
@@ -48,6 +66,21 @@ export const ROUTES = [
         aliasesArePinned: true,
         implemented: false, // needs Google OAuth
     },
+    {
+        // Azure hosts OpenAI's models under a company's own subscription, which is
+        // the answer for someone who wants codex billed through work rather than a
+        // personal card. Same wire as OpenAI, but the key travels in its own
+        // header and the deployment name lives in the URL.
+        id: "azure-openai",
+        vendor: "OpenAI",
+        label: "Azure OpenAI",
+        hint: "your Azure subscription owns auth and billing",
+        wire: "openai",
+        needsBaseUrl: true,
+        keyEnv: "AZURE_OPENAI_API_KEY",
+        aliasesArePinned: true, // you address deployments, not model ids
+        implemented: true,
+    },
     {
         id: "openai-api",
         vendor: "OpenAI",

package/dist/sigv4.js

@@ -93,7 +93,7 @@ export async function discoverAwsCredentials(profileName = process.env.AWS_PROFI
             accessKeyId: process.env.AWS_ACCESS_KEY_ID,
             secretAccessKey: process.env.AWS_SECRET_ACCESS_KEY,
             sessionToken: process.env.AWS_SESSION_TOKEN,
-            source: "environment",
+            source: "your environment",
         };
     }
     // 2. container credential endpoint (ECS, SageMaker, CodeBuild)
@@ -130,7 +130,7 @@ async function fetchContainerCredentials(url) {
             accessKeyId: b.AccessKeyId,
             secretAccessKey: b.SecretAccessKey,
             sessionToken: b.Token,
-            source: "container credentials endpoint",
+            source: "this environment's role",
         };
     }
     catch {
@@ -175,3 +175,51 @@ export function readSharedCredentials(profileName = "default", file = path.join(
         source: `~/.aws/credentials [${wanted}]`,
     };
 }
+/**
+ * Find the AWS region the way the SDKs do.
+ *
+ * Credentials don't carry a region, but the endpoint and the signature both
+ * need one — so it has to come from somewhere. In SageMaker, Lambda and ECS
+ * it's already in the environment, and on a laptop it's usually in the config
+ * file, which means asking is normally an unnecessary question.
+ */
+export function discoverAwsRegion(profileName = process.env.AWS_PROFILE ?? "default", file = path.join(os.homedir(), ".aws", "config")) {
+    const env = process.env.AWS_REGION ?? process.env.AWS_DEFAULT_REGION;
+    if (env) {
+        return {
+            region: env,
+            source: process.env.AWS_REGION ? "AWS_REGION" : "AWS_DEFAULT_REGION",
+        };
+    }
+    // ~/.aws/config uses "[profile name]" for everything except default
+    let text;
+    try {
+        text = fs.readFileSync(file, "utf8");
+    }
+    catch {
+        return undefined;
+    }
+    const wanted = profileName === "default" ? "default" : `profile ${profileName}`;
+    let current = "";
+    for (const raw of text.split("\n")) {
+        const line = raw.split(/[#;]/)[0].trim();
+        if (!line)
+            continue;
+        const header = /^\[(.+)\]$/.exec(line);
+        if (header) {
+            current = header[1].trim();
+            continue;
+        }
+        if (current !== wanted)
+            continue;
+        const eq = line.indexOf("=");
+        if (eq === -1)
+            continue;
+        if (line.slice(0, eq).trim().toLowerCase() === "region") {
+            const region = line.slice(eq + 1).trim();
+            if (region)
+                return { region, source: `~/.aws/config [${profileName}]` };
+        }
+    }
+    return undefined;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "faberwright",
-  "version": "0.4.1",
+  "version": "0.4.3",
   "description": "Faber: an agentic AI coding assistant for your terminal — streams, edits with diff approval, runs your tests, and remembers your project across sessions.",
   "type": "module",
   "license": "Apache-2.0",