faberwright 0.3.0 → 0.4.0

package/dist/routes.js

@@ -0,0 +1,143 @@
+/**
+ * Vendors, routes, and model aliases.
+ *
+ * Three levels, chosen in order:
+ *   vendor  — who makes the model (Anthropic, OpenAI-compatible)
+ *   route   — how you reach it and who owns authentication
+ *             (direct API key, a cloud provider, a local server, a gateway)
+ *   model   — an alias (sonnet/opus/haiku) or a raw model id
+ *
+ * Aliases exist because the same model has different ids on different routes:
+ * the direct API calls it "claude-sonnet-5" while Bedrock wants a long
+ * region-prefixed inference-profile id. Aliases stay stable; the mapping moves.
+ * For cloud routes the mapping is USER-SUPPLIED — we never guess ids we can't
+ * verify, since a wrong one fails at request time with a confusing error.
+ */
+export const ROUTES = [
+    {
+        id: "anthropic-api",
+        vendor: "Anthropic",
+        label: "Anthropic API",
+        hint: "direct, pay per token with your own key",
+        wire: "anthropic",
+        baseUrl: "https://api.anthropic.com",
+        keyEnv: "ANTHROPIC_API_KEY",
+        implemented: true,
+    },
+    {
+        // AWS's bedrock-mantle endpoint speaks the first-party Messages dialect and
+        // authenticates with a Bedrock API key, so no SigV4 signing is needed —
+        // only the base URL and the credential differ from the direct route.
+        id: "bedrock",
+        vendor: "Anthropic",
+        label: "Amazon Bedrock",
+        hint: "your AWS account owns auth and billing",
+        wire: "anthropic",
+        needsRegion: true,
+        baseUrlTemplate: "https://bedrock-mantle.{region}.api.aws/anthropic",
+        keyEnv: "BEDROCK_API_KEY",
+        aliasesArePinned: true, // Bedrock model ids differ per region/deployment
+        implemented: true,
+    },
+    {
+        id: "vertex",
+        vendor: "Anthropic",
+        label: "Google Vertex AI",
+        hint: "your GCP project owns auth and billing",
+        wire: "anthropic",
+        aliasesArePinned: true,
+        implemented: false, // needs Google OAuth
+    },
+    {
+        id: "openai-api",
+        vendor: "OpenAI",
+        label: "OpenAI API",
+        hint: "direct, with your own key",
+        wire: "openai",
+        baseUrl: "https://api.openai.com/v1",
+        keyEnv: "OPENAI_API_KEY",
+        implemented: true,
+    },
+    {
+        id: "ollama",
+        vendor: "Local",
+        label: "Ollama (local)",
+        hint: "runs on your machine, no key, no cost",
+        wire: "openai",
+        baseUrl: "http://localhost:11434/v1",
+        aliasesArePinned: true,
+        implemented: true,
+    },
+    {
+        id: "custom",
+        vendor: "Other",
+        label: "OpenAI-compatible endpoint",
+        hint: "OpenRouter, Groq, Together, vLLM, a gateway…",
+        wire: "openai",
+        needsBaseUrl: true,
+        keyEnv: "OPENAI_API_KEY",
+        aliasesArePinned: true,
+        implemented: true,
+    },
+];
+export function getRoute(id) {
+    return ROUTES.find((r) => r.id === id);
+}
+export const DEFAULT_REGION = "us-east-1";
+/** Endpoint for a route, substituting the region into region-scoped URLs. */
+export function baseUrlFor(route, region) {
+    if (route.baseUrlTemplate) {
+        return route.baseUrlTemplate.replace("{region}", region || DEFAULT_REGION);
+    }
+    return route.baseUrl;
+}
+/** Vendors in menu order, each with its routes. */
+export function vendors() {
+    const out = [];
+    for (const r of ROUTES) {
+        const found = out.find((v) => v.vendor === r.vendor);
+        if (found)
+            found.routes.push(r);
+        else
+            out.push({ vendor: r.vendor, routes: [r] });
+    }
+    return out;
+}
+/**
+ * Built-in aliases for the direct Anthropic API. Ids on cloud routes differ
+ * per deployment and region, so those are pinned by the user instead.
+ */
+export const ANTHROPIC_MODELS = [
+    { alias: "sonnet", id: "claude-sonnet-5", blurb: "balanced — good default for daily work" },
+    { alias: "opus", id: "claude-opus-5", blurb: "most capable — complex, multi-step work" },
+    { alias: "haiku", id: "claude-haiku-4-5-20251001", blurb: "fastest and cheapest — simple tasks" },
+];
+export const OPENAI_MODELS = [
+    { alias: "gpt", id: "gpt-4o", blurb: "general purpose" },
+    { alias: "mini", id: "gpt-4o-mini", blurb: "cheaper and faster" },
+];
+/** Models offered for a route; empty when ids must be pinned by the user. */
+export function modelsForRoute(route) {
+    if (route.aliasesArePinned)
+        return [];
+    return route.wire === "anthropic" ? ANTHROPIC_MODELS : OPENAI_MODELS;
+}
+/**
+ * Turn whatever the user typed into a concrete model id.
+ * Order: explicit per-route pin > built-in alias > treat it as a raw id.
+ */
+export function resolveModel(input, route, pins = {}) {
+    const key = input.trim();
+    if (pins[key])
+        return pins[key];
+    const hit = modelsForRoute(route).find((m) => m.alias === key);
+    return hit ? hit.id : key;
+}
+/** Reverse lookup: show "sonnet (claude-sonnet-5)" instead of a bare id. */
+export function describeModel(id, route, pins = {}) {
+    const pinned = Object.entries(pins).find(([, v]) => v === id);
+    if (pinned)
+        return `${pinned[0]} (${id})`;
+    const hit = modelsForRoute(route).find((m) => m.id === id);
+    return hit ? `${hit.alias} (${id})` : id;
+}

package/dist/settings.js

@@ -0,0 +1,55 @@
+/**
+ * Global settings: ~/.faber/settings.json
+ *
+ * Holds named profiles — a route, a model, and any endpoint or credential
+ * REFERENCE that route needs. Credentials themselves are never stored here:
+ * a profile names the environment variable to read (`apiKeyEnv`), so this file
+ * stays safe to sync between machines or check into a dotfiles repo.
+ *
+ * Resolution order, highest first:
+ *   env vars  >  <project>/.faber/config.json  >  active profile  >  defaults
+ * Project settings beat the global profile so a repo can pin its own model,
+ * and env vars beat everything so CI and one-off overrides always work.
+ */
+import * as fs from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
+export const DEFAULT_SETTINGS = {
+    activeProfile: "default",
+    profiles: {
+        default: { route: "anthropic-api", model: "sonnet", apiKeyEnv: "ANTHROPIC_API_KEY" },
+    },
+};
+export function settingsPath() {
+    return path.join(os.homedir(), ".faber", "settings.json");
+}
+export function loadSettings(file = settingsPath()) {
+    try {
+        const raw = JSON.parse(fs.readFileSync(file, "utf8"));
+        const profiles = raw.profiles && typeof raw.profiles === "object"
+            ? raw.profiles
+            : DEFAULT_SETTINGS.profiles;
+        const active = typeof raw.activeProfile === "string" && profiles[raw.activeProfile]
+            ? raw.activeProfile
+            : Object.keys(profiles)[0] ?? "default";
+        return { activeProfile: active, profiles };
+    }
+    catch {
+        return structuredClone(DEFAULT_SETTINGS); // absent or malformed -> defaults
+    }
+}
+export function saveSettings(s, file = settingsPath()) {
+    fs.mkdirSync(path.dirname(file), { recursive: true });
+    fs.writeFileSync(file, JSON.stringify(s, null, 2) + "\n");
+}
+export function activeProfile(s) {
+    return s.profiles[s.activeProfile] ?? DEFAULT_SETTINGS.profiles.default;
+}
+/** Update the active profile in place and persist. */
+export function updateActive(patch, file = settingsPath()) {
+    const s = loadSettings(file);
+    const name = s.activeProfile;
+    s.profiles[name] = { ...activeProfile(s), ...patch };
+    saveSettings(s, file);
+    return s;
+}

package/dist/sigv4.js

@@ -0,0 +1,177 @@
+/**
+ * AWS SigV4 request signing.
+ *
+ * Why this exists: in SageMaker Studio, EC2, ECS, Lambda and anywhere else AWS
+ * injects an execution role, there IS no API key — credentials arrive as an
+ * access key / secret / session token trio, and requests are authenticated by
+ * signing them. That's the natural auth path in those environments, and a
+ * Bedrock API key would be a second, unnecessary credential.
+ *
+ * Implemented directly rather than pulling in the AWS SDK: the signing
+ * algorithm is ~80 lines of HMAC chaining, and the SDK would add dozens of
+ * transitive dependencies to a tool whose whole install story is "zero native
+ * deps, nothing to compile".
+ *
+ * Verified against the signing test vectors AWS publishes for the algorithm.
+ */
+import { createHash, createHmac } from "node:crypto";
+import * as fs from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
+const sha256 = (data) => createHash("sha256").update(data).digest("hex");
+const hmac = (key, data) => createHmac("sha256", key).update(data, "utf8").digest();
+/** ISO8601 basic format: 20260808T210000Z */
+export function amzDate(d = new Date()) {
+    return d.toISOString().replace(/[:-]|\.\d{3}/g, "");
+}
+/**
+ * Canonical request -> string to sign -> signing key -> Authorization header.
+ * Header names are lowercased and sorted; the payload is hashed. Any deviation
+ * produces a signature mismatch, so the ordering here is load-bearing.
+ */
+export function signRequest(opts) {
+    const { method, body, region, service, credentials } = opts;
+    const url = new URL(opts.url);
+    const now = opts.now ?? new Date();
+    const stamp = amzDate(now);
+    const date = stamp.slice(0, 8);
+    const headers = {
+        host: url.host,
+        "x-amz-date": stamp,
+        ...Object.fromEntries(Object.entries(opts.headers ?? {}).map(([k, v]) => [k.toLowerCase(), v])),
+    };
+    if (credentials.sessionToken)
+        headers["x-amz-security-token"] = credentials.sessionToken;
+    const signedHeaderNames = Object.keys(headers).sort();
+    const canonicalHeaders = signedHeaderNames
+        .map((h) => `${h}:${headers[h].trim().replace(/\s+/g, " ")}\n`)
+        .join("");
+    const signedHeaders = signedHeaderNames.join(";");
+    // query params must be sorted and percent-encoded
+    const canonicalQuery = [...url.searchParams.entries()]
+        .sort(([a], [b]) => (a < b ? -1 : a > b ? 1 : 0))
+        .map(([k, v]) => `${encodeURIComponent(k)}=${encodeURIComponent(v)}`)
+        .join("&");
+    const payloadHash = sha256(body);
+    const canonicalRequest = [
+        method.toUpperCase(),
+        url.pathname || "/",
+        canonicalQuery,
+        canonicalHeaders,
+        signedHeaders,
+        payloadHash,
+    ].join("\n");
+    const scope = `${date}/${region}/${service}/aws4_request`;
+    const stringToSign = [
+        "AWS4-HMAC-SHA256",
+        stamp,
+        scope,
+        sha256(canonicalRequest),
+    ].join("\n");
+    const kDate = hmac(`AWS4${credentials.secretAccessKey}`, date);
+    const kRegion = hmac(kDate, region);
+    const kService = hmac(kRegion, service);
+    const kSigning = hmac(kService, "aws4_request");
+    const signature = createHmac("sha256", kSigning).update(stringToSign, "utf8").digest("hex");
+    return {
+        ...headers,
+        authorization: `AWS4-HMAC-SHA256 Credential=${credentials.accessKeyId}/${scope}, ` +
+            `SignedHeaders=${signedHeaders}, Signature=${signature}`,
+        "x-amz-content-sha256": payloadHash,
+    };
+}
+// ────────────────────────────────────────────── credential discovery
+/**
+ * Find AWS credentials the way the SDKs do, in the same order. In SageMaker
+ * Studio, ECS and Lambda the environment or the container endpoint is
+ * populated automatically, so this returns credentials with no setup at all.
+ */
+export async function discoverAwsCredentials(profileName = process.env.AWS_PROFILE ?? "default") {
+    // 1. environment (SageMaker Studio, CI, explicit exports)
+    if (process.env.AWS_ACCESS_KEY_ID && process.env.AWS_SECRET_ACCESS_KEY) {
+        return {
+            accessKeyId: process.env.AWS_ACCESS_KEY_ID,
+            secretAccessKey: process.env.AWS_SECRET_ACCESS_KEY,
+            sessionToken: process.env.AWS_SESSION_TOKEN,
+            source: "environment",
+        };
+    }
+    // 2. container credential endpoint (ECS, SageMaker, CodeBuild)
+    const relUri = process.env.AWS_CONTAINER_CREDENTIALS_RELATIVE_URI;
+    const fullUri = process.env.AWS_CONTAINER_CREDENTIALS_FULL_URI;
+    if (relUri || fullUri) {
+        const url = fullUri ?? `http://169.254.170.2${relUri}`;
+        const creds = await fetchContainerCredentials(url);
+        if (creds)
+            return creds;
+    }
+    // 3. shared credentials file (a laptop with `aws configure` run)
+    const fromFile = readSharedCredentials(profileName);
+    if (fromFile)
+        return fromFile;
+    return undefined;
+}
+async function fetchContainerCredentials(url) {
+    try {
+        const ctl = new AbortController();
+        const timer = setTimeout(() => ctl.abort(), 3000);
+        const headers = {};
+        const token = process.env.AWS_CONTAINER_AUTHORIZATION_TOKEN;
+        if (token)
+            headers.authorization = token;
+        const res = await fetch(url, { headers, signal: ctl.signal });
+        clearTimeout(timer);
+        if (!res.ok)
+            return undefined;
+        const b = await res.json();
+        if (!b.AccessKeyId || !b.SecretAccessKey)
+            return undefined;
+        return {
+            accessKeyId: b.AccessKeyId,
+            secretAccessKey: b.SecretAccessKey,
+            sessionToken: b.Token,
+            source: "container credentials endpoint",
+        };
+    }
+    catch {
+        return undefined;
+    }
+}
+/** Minimal INI reader for ~/.aws/credentials — no dependency needed. */
+export function readSharedCredentials(profileName = "default", file = path.join(os.homedir(), ".aws", "credentials")) {
+    let text;
+    try {
+        text = fs.readFileSync(file, "utf8");
+    }
+    catch {
+        return undefined;
+    }
+    const wanted = profileName.replace(/^profile\s+/, "");
+    let current = "";
+    const section = {};
+    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].replace(/^profile\s+/, "").trim();
+            continue;
+        }
+        if (current !== wanted)
+            continue;
+        const eq = line.indexOf("=");
+        if (eq === -1)
+            continue;
+        section[line.slice(0, eq).trim().toLowerCase()] = line.slice(eq + 1).trim();
+    }
+    const id = section["aws_access_key_id"], secret = section["aws_secret_access_key"];
+    if (!id || !secret)
+        return undefined;
+    return {
+        accessKeyId: id,
+        secretAccessKey: secret,
+        sessionToken: section["aws_session_token"],
+        source: `~/.aws/credentials [${wanted}]`,
+    };
+}

package/dist/usage.js

@@ -9,10 +9,15 @@ import * as fs from "node:fs";
 import * as os from "node:os";
 import * as path from "node:path";
 import { DatabaseSync } from "node:sqlite";
+import { priceFor, cacheReadPrice, cacheWritePrice, PRICES_AS_OF, readPriceCache, priceAgeDays, STALE_AFTER_DAYS } from "./pricing.js";
 export class UsageLedger {
     projectPath;
     db;
     session = { input: 0, cacheRead: 0, cacheWrite: 0, output: 0, calls: 0, tasks: 0 };
+    /** Model used by the most recent task. */
+    currentModel = "";
+    /** When this process started, so the session row can be priced per model. */
+    sessionStart = Date.now();
     constructor(dbPath, projectPath) {
         this.projectPath = projectPath;
         this.db = new DatabaseSync(dbPath);
@@ -20,11 +25,28 @@ export class UsageLedger {
         this.db.exec(`CREATE TABLE IF NOT EXISTS tasks (
       ts INTEGER, input INTEGER, cache_read INTEGER, cache_write INTEGER,
       output INTEGER, calls INTEGER, model TEXT)`);
+        // Cost is recorded when the task runs, at the prices in effect then.
+        // Prices change; money already spent does not. Ledgers created before this
+        // column existed keep NULL and are priced at display time as a fallback.
+        for (const col of ["cost REAL", "saved REAL"]) {
+            try {
+                this.db.exec(`ALTER TABLE tasks ADD COLUMN ${col}`);
+            }
+            catch { /* already migrated */ }
+        }
         this.registerProject();
     }
-    record(u, model) {
-        this.db.prepare("INSERT INTO tasks VALUES (?, ?, ?, ?, ?, ?, ?)")
-            .run(Date.now(), u.input, u.cacheRead, u.cacheWrite, u.output, u.calls, model);
+    /**
+     * Record a completed task. Cost is computed and stored NOW, using the prices
+     * in effect at this moment — later price changes never rewrite it.
+     */
+    record(u, model, override) {
+        this.currentModel = model;
+        const p = priceFor(model, override);
+        const cost = UsageLedger.cost(u, p) ?? null;
+        const saved = UsageLedger.saved(u, p) ?? null;
+        this.db.prepare("INSERT INTO tasks VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)")
+            .run(Date.now(), u.input, u.cacheRead, u.cacheWrite, u.output, u.calls, model, cost, saved);
         this.session.input += u.input;
         this.session.cacheRead += u.cacheRead;
         this.session.cacheWrite += u.cacheWrite;
@@ -38,18 +60,38 @@ export class UsageLedger {
               COALESCE(SUM(calls),0) calls
        FROM tasks WHERE ts >= ?`).get(sinceMs ?? 0);
     }
-    /** Cost in USD; undefined when CW_PRICE_IN/OUT aren't configured. */
-    static cost(u, priceIn, priceOut) {
-        if (!priceIn || !priceOut)
+    /** Cost in USD for one usage record at a given model's prices. */
+    static cost(u, p) {
+        if (!p)
             return undefined;
-        return (u.input * priceIn + u.cacheRead * priceIn * 0.1 +
-            u.cacheWrite * priceIn * 1.25 + u.output * priceOut) / 1e6;
+        return (u.input * p.in + u.cacheRead * cacheReadPrice(p) +
+            u.cacheWrite * cacheWritePrice(p) + u.output * p.out) / 1e6;
     }
-    /** Net savings from caching vs paying full input price (reads at 0.1x minus write premium). */
-    static saved(u, priceIn) {
-        if (!priceIn)
+    /** What caching saved vs paying full input price, net of the write premium. */
+    static saved(u, p) {
+        if (!p)
             return undefined;
-        return (u.cacheRead * priceIn * 0.9 - u.cacheWrite * priceIn * 0.25) / 1e6;
+        const readSaving = u.cacheRead * (p.in - cacheReadPrice(p));
+        const writePremium = u.cacheWrite * (cacheWritePrice(p) - p.in);
+        return (readSaving - writePremium) / 1e6;
+    }
+    /**
+     * Totals split by model, so a history spanning several models is priced with
+     * each model's own rates rather than whatever is loaded right now.
+     */
+    get startedAt() { return this.sessionStart; }
+    totalsByModel(sinceMs) {
+        const rows = this.db.prepare(`SELECT model, COUNT(*) tasks, COALESCE(SUM(input),0) input,
+              COALESCE(SUM(cache_read),0) cacheRead, COALESCE(SUM(cache_write),0) cacheWrite,
+              COALESCE(SUM(output),0) output, COALESCE(SUM(calls),0) calls,
+              SUM(cost) billedCost, SUM(saved) billedSaved,
+              SUM(CASE WHEN cost IS NULL THEN 1 ELSE 0 END) unpriced
+       FROM tasks WHERE ts >= ? GROUP BY model`).all(sinceMs ?? 0);
+        return rows.map((r) => ({
+            model: r.model,
+            totals: r,
+            billed: { cost: r.billedCost, saved: r.billedSaved, unpriced: r.unpriced },
+        }));
     }
     // ---- global registry so usage can be summed across every project ----
     registerProject() {
@@ -104,31 +146,89 @@ export class UsageLedger {
 const k = (n) => n >= 1_000_000 ? (n / 1_000_000).toFixed(1) + "M"
     : n >= 1000 ? (n / 1000).toFixed(1) + "k" : String(n);
 const money = (v) => v === undefined ? "—" : `$${v.toFixed(2)}`;
-/** Render the /usage stats panel. */
-export function renderUsagePanel(ledger, priceIn, priceOut) {
+/**
+ * Render the /usage panel. Each row is priced per model using that model's own
+ * rates, so a history that spans a switch from Sonnet to Opus stays accurate.
+ */
+export function renderUsagePanel(ledger, override) {
     const midnight = new Date();
     midnight.setHours(0, 0, 0, 0);
-    const rows = [
-        ["this session", ledger.session],
-        ["today", ledger.totals(midnight.getTime())],
-        ["all time", ledger.totals()],
+    const windows = [
+        ["this session", undefined],
+        ["today", midnight.getTime()],
+        ["all time", 0],
     ];
     const lines = [];
     const W = [13, 7, 12, 9, 7, 9, 9];
     const cells = (c) => c.map((s, i) => s.padEnd(W[i])).join(" ");
     lines.push(cells(["", "tasks", "in", "cached", "out", "cost", "saved"]));
-    for (const [label, t] of rows) {
-        const totalIn = t.input + t.cacheRead + t.cacheWrite;
-        const pct = totalIn > 0 ? Math.round((t.cacheRead / totalIn) * 100) + "%" : "0%";
-        lines.push(cells([
-            label, String(t.tasks), k(totalIn), pct, k(t.output),
-            money(UsageLedger.cost(t, priceIn, priceOut)),
-            money(UsageLedger.saved(t, priceIn)),
-        ]));
+    let anyPriced = false;
+    let legacyRows = 0;
+    let estimated = false;
+    for (const [label, since] of windows) {
+        // session totals come from memory; the rest are priced per model from disk
+        // Every window is priced per model — including the session, which would
+        // otherwise apply the last-used model's rates to earlier tasks.
+        const bands = ledger.totalsByModel(since ?? ledger.startedAt);
+        const agg = { input: 0, cacheRead: 0, cacheWrite: 0, output: 0, calls: 0, tasks: 0 };
+        let cost;
+        let saved;
+        for (const b of bands) {
+            agg.input += b.totals.input;
+            agg.cacheRead += b.totals.cacheRead;
+            agg.cacheWrite += b.totals.cacheWrite;
+            agg.output += b.totals.output;
+            agg.calls += b.totals.calls;
+            agg.tasks += b.totals.tasks;
+            // Historical cost is whatever was charged at the time — never repriced.
+            if (b.billed.cost !== null) {
+                cost = (cost ?? 0) + b.billed.cost;
+                anyPriced = true;
+            }
+            if (b.billed.saved !== null)
+                saved = (saved ?? 0) + b.billed.saved;
+            if (b.billed.unpriced > 0) {
+                // Rows recorded before costs were stored have nothing to preserve, so
+                // estimate them at today's prices and flag the row as an estimate.
+                legacyRows += b.billed.unpriced;
+                const p = priceFor(b.model, override);
+                const c = UsageLedger.cost(b.totals, p);
+                const s = UsageLedger.saved(b.totals, p);
+                if (c !== undefined) {
+                    cost = (cost ?? 0) + c;
+                    anyPriced = true;
+                    estimated = true;
+                }
+                if (s !== undefined)
+                    saved = (saved ?? 0) + s;
+            }
+        }
+        const totalIn = agg.input + agg.cacheRead + agg.cacheWrite;
+        const pct = totalIn > 0 ? Math.round((agg.cacheRead / totalIn) * 100) + "%" : "0%";
+        lines.push(cells([label, String(agg.tasks), k(totalIn), pct, k(agg.output),
+            money(cost), money(saved)]));
+    }
+    if (anyPriced) {
+        const src = readPriceCache();
+        lines.push("");
+        lines.push("cost is what each task was charged when it ran — later price changes don't rewrite it");
+        const age = priceAgeDays();
+        if (src && age !== undefined) {
+            const when = new Date(src.fetchedAt).toISOString().slice(0, 10);
+            lines.push(age > STALE_AFTER_DAYS
+                ? `new tasks priced from rates fetched ${when} (${Math.round(age)} days ago — consider /usage --refresh-prices)`
+                : `new tasks priced from rates fetched ${when}`);
+        }
+        else {
+            lines.push(`new tasks priced from built-in rates, as of ${PRICES_AS_OF} — /usage --refresh-prices for current`);
+        }
+        if (legacyRows) {
+            lines.push(`${legacyRows} older task(s) predate cost tracking${estimated ? " — estimated at today's rates" : ""}`);
+        }
     }
-    if (!priceIn || !priceOut) {
+    else {
         lines.push("");
-        lines.push("set CW_PRICE_IN and CW_PRICE_OUT ($/Mtok) to see cost and savings");
+        lines.push("no price known for this model — set FABER_PRICE_IN / FABER_PRICE_OUT");
     }
     const others = UsageLedger.allProjects().filter((p) => p.totals.tasks > 0);
     if (others.length > 1) {
@@ -139,7 +239,7 @@ export function renderUsagePanel(ledger, priceIn, priceOut) {
             lines.push(cells([
                 "  " + path.basename(project).slice(0, 11), String(t.tasks), k(totalIn),
                 totalIn > 0 ? Math.round((t.cacheRead / totalIn) * 100) + "%" : "0%",
-                k(t.output), money(UsageLedger.cost(t, priceIn, priceOut)), "",
+                k(t.output), "", "",
             ]));
         }
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "faberwright",
-  "version": "0.3.0",
+  "version": "0.4.0",
   "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",
@@ -45,5 +45,13 @@
     "developer-tools",
     "terminal",
     "llm"
-  ]
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/JibanKumar-cloud/faber.git"
+  },
+  "homepage": "https://github.com/JibanKumar-cloud/faber#readme",
+  "bugs": {
+    "url": "https://github.com/JibanKumar-cloud/faber/issues"
+  }
 }