@tiens.nguyen/gu-cli 1.0.783 → 1.0.785

package/model-prices.mjs

@@ -0,0 +1,484 @@
+/**
+ * MODEL PRICES AND WHAT A TURN COST (#323).
+ *
+ * The user: "estimate cost of USD after each turn" — from each provider's price per 1 million INPUT
+ * tokens (output ignored for now, but stored so turning it on needs no migration), with the cheaper
+ * CACHED-input price for the part of each step the provider served from its prompt cache.
+ *
+ * HOW MUCH WAS CACHED. The agent reads the provider's own count when it reports one (OpenAI
+ * usage.prompt_tokens_details.cached_tokens, Anthropic cache_read_input_tokens, Kimi cached_tokens
+ * — see _cached_tokens_from_usage in gonext_agent_chat.py) and the cost then uses it: "$0.04".
+ * When nothing is reported, gu ASSUMES 90% of every step after the first was cached — what the
+ * user sees on the Kimi and Claude consoles for gu's turns — and says so: "~$0.04".
+ *
+ * Prices live in the user's own Mongo (one row per server + model, via the local API); this file is
+ * pure — the table it ships (PRICE_TABLE) is what an empty Mongo is seeded with, and what the Deploy
+ * app's "Prices" button exports for the admin to publish.
+ */
+
+export const PRICE_TABLE_VERSION = "1.0";
+/** Of a step after the first, the share assumed served from the cache when the provider says nothing. */
+export const ASSUMED_CACHED_SHARE = 0.9;
+export const MAX_PRICE_ROWS = 500;
+const MAX_PRICE = 1000; // USD per 1M tokens — anything above is a typo (per-token, per-1k…)
+
+const ANTHROPIC = "https://platform.claude.com/docs/en/about-claude/pricing";
+const OPENAI = "https://developers.openai.com/api/docs/pricing";
+const KIMI = "https://platform.kimi.ai/docs/pricing/chat";
+const OLLAMA = "https://ollama.com/pricing";
+const CHECKED = "2026-10-01";
+
+/** [host, model, input, cachedInput, output, cacheWrite?] — USD per 1M tokens. */
+const ROWS = [
+  // Anthropic — cache write (5 minutes) is 1.25× input; gu does not price writes yet (noted per row).
+  ["api.anthropic.com", "claude-fable-5-1", 10, 0.25, 50, 12.5],
+  ["api.anthropic.com", "claude-opus-5-5", 4, 0.2, 20, 5],
+  ["api.anthropic.com", "claude-opus-5", 5, 0.5, 25, 6.25],
+  ["api.anthropic.com", "claude-opus-4-8", 5, 0.5, 25, 6.25],
+  ["api.anthropic.com", "claude-sonnet-5-5", 2, 0.2, 10, 2.5],
+  ["api.anthropic.com", "claude-sonnet-5", 2, 0.2, 10, 2.5],
+  ["api.anthropic.com", "claude-sonnet-4-6", 3, 0.3, 15, 3.75],
+  ["api.anthropic.com", "claude-sonnet-4-5", 3, 0.3, 15, 3.75],
+  ["api.anthropic.com", "claude-haiku-4-5", 1, 0.1, 5, 1.25],
+  // OpenAI (standard tier)
+  ["api.openai.com", "gpt-6-astra", 10, 1, 50],
+  ["api.openai.com", "gpt-6.1-sol", 2, 0.1, 10],
+  ["api.openai.com", "gpt-6-sol", 2, 0.2, 10],
+  ["api.openai.com", "gpt-6-luna", 0.1, 0.01, 0.5],
+  ["api.openai.com", "gpt-5.6-sol", 4, 0.4, 20],
+  ["api.openai.com", "gpt-5.6-terra", 2, 0.2, 12],
+  ["api.openai.com", "gpt-5.6-luna", 0.2, 0.02, 1.2],
+  ["api.openai.com", "gpt-5.5", 5, 0.5, 30],
+  ["api.openai.com", "gpt-5.4", 2.5, 0.25, 15],
+  ["api.openai.com", "gpt-5.3-codex", 1.75, 0.175, 14],
+  ["api.openai.com", "gpt-5.2", 1.75, 0.175, 14],
+  ["api.openai.com", "gpt-5.1", 1.25, 0.125, 10],
+  ["api.openai.com", "gpt-5", 1.25, 0.125, 10],
+  ["api.openai.com", "gpt-4.1", 2, 0.5, 8],
+  ["api.openai.com", "gpt-4o", 2.5, 1.25, 10],
+  // Moonshot / Kimi
+  ["api.moonshot.ai", "kimi-k3", 3, 0.3, 15, 3], // cache write (5 min) = the input price
+  ["api.moonshot.ai", "kimi-k2.7-code", 0.95, 0.19, 4],
+  ["api.moonshot.ai", "kimi-k2.7-code-highspeed", 1.9, 0.38, 8],
+  ["api.moonshot.ai", "kimi-k2.6", 0.95, 0.16, 4],
+  // Ollama cloud — pay-as-you-go credits (peak price; off-peak is about half)
+  ["ollama.com", "kimi-k3", 3, 0.3, 15],
+  ["ollama.com", "kimi-k2.7-code", 0.95, 0.19, 4],
+  ["ollama.com", "kimi-k2.6", 0.95, 0.16, 4],
+  ["ollama.com", "glm-5.3", 1.4, 0.26, 4.4],
+  ["ollama.com", "glm-5.3-flash", 0.15, 0.03, 0.5],
+  ["ollama.com", "glm-5.2", 1.4, 0.26, 4.4],
+  ["ollama.com", "deepseek-v4-pro", 1.32, 0.044, 3.96],
+  ["ollama.com", "deepseek-v4.1-flash", 0.3, 0.006, 1.2],
+  ["ollama.com", "minimax-m3", 0.6, 0.12, 2.4],
+  ["ollama.com", "minimax-m2.7", 0.3, 0.06, 1.2],
+  ["ollama.com", "gpt-oss:120b", 0.15, 0.014, 0.6],
+  ["ollama.com", "gpt-oss:20b", 0.07, 0.035, 0.3],
+  ["ollama.com", "gemma4", 0.14, 0.05, 0.4],
+  ["ollama.com", "mistral-large-3", 0.5, null, 1.5],
+  ["ollama.com", "nemotron-3-nano", 0.06, null, 0.24],
+  ["ollama.com", "nemotron-3-super", 0.015, 0.015, 0.6],
+  ["ollama.com", "nemotron-3-ultra", 0.1, 0.1, 3],
+];
+const PROVIDER = { "api.anthropic.com": "Anthropic", "api.openai.com": "OpenAI", "api.moonshot.ai": "Moonshot (Kimi)", "ollama.com": "Ollama cloud" };
+const SOURCE = { "api.anthropic.com": ANTHROPIC, "api.openai.com": OPENAI, "api.moonshot.ai": KIMI, "ollama.com": OLLAMA };
+
+/** The table gu ships — what an empty Mongo is seeded with and what the Deploy app exports. */
+export const PRICE_TABLE = Object.freeze({
+  gu: "prices",
+  version: PRICE_TABLE_VERSION,
+  publishedAt: CHECKED,
+  currency: "USD",
+  unit: "per 1M tokens",
+  note: "input = uncached prompt tokens; cachedInput = prompt tokens served from the provider's cache; output is stored but not yet used. Anthropic cache writes (cacheWrite) are not priced yet. Ollama cloud: peak prices — off-peak is about half.",
+  prices: ROWS.map(([host, model, input, cachedInput, output, cacheWrite]) => ({
+    provider: PROVIDER[host],
+    host,
+    model,
+    input,
+    cachedInput,
+    output,
+    ...(cacheWrite != null ? { cacheWrite } : {}),
+    // Used only when the provider does not report its cached count: Kimi and OpenAI cache prompt
+    // prefixes automatically; Anthropic only when the request asks (gu's Claude path does); Ollama
+    // cloud lists cache prices. No cache price → no discount, so no share.
+    ...(cachedInput != null ? { assumedCacheShare: ASSUMED_CACHED_SHARE } : {}),
+    source: SOURCE[host],
+    checkedAt: CHECKED,
+  })),
+});
+
+// ---------------------------------------------------------------------------------------------
+// keys and lookup
+// ---------------------------------------------------------------------------------------------
+
+/** A server URL (or bare host) → its host: "https://api.moonshot.ai/v1/" → "api.moonshot.ai". */
+export function hostOf(urlOrHost) {
+  const raw = String(urlOrHost ?? "").trim();
+  if (!raw) return "";
+  try {
+    return new URL(raw.includes("://") ? raw : `https://${raw}`).host.toLowerCase();
+  } catch {
+    return raw.replace(/^[a-z]+:\/\//i, "").replace(/\/.*$/, "").toLowerCase();
+  }
+}
+
+/** One row's identity: host + model, lower-cased. */
+export const priceKey = (host, model) => `${hostOf(host)}|${String(model ?? "").trim().toLowerCase()}`;
+
+/**
+ * The price for a server + model, or null. Exact first; then without a dated suffix
+ * ("claude-haiku-4-5-20251001" → "claude-haiku-4-5"); then without an Ollama tag ("kimi-k3:cloud",
+ * "kimi-k3:latest" → "kimi-k3"). Never a different host — the same model costs differently there.
+ */
+export function findPrice(rows, url, model) {
+  const host = hostOf(url);
+  const m = String(model ?? "").trim().toLowerCase();
+  if (!host || !m || !Array.isArray(rows)) return null;
+  const byKey = new Map(rows.map((r) => [priceKey(r.host, r.model), r]));
+  const tries = [m, m.replace(/-\d{8}$/, ""), m.replace(/:(cloud|latest)$/, "")];
+  for (const t of tries) {
+    const r = byKey.get(`${host}|${t}`);
+    if (r) return r;
+  }
+  return null;
+}
+
+// ---------------------------------------------------------------------------------------------
+// what a turn cost
+// ---------------------------------------------------------------------------------------------
+
+/**
+ * The input cost of one turn.
+ *   input          prompt tokens sent, summed over every step of the turn
+ *   cached         prompt tokens the provider served from its cache (summed), when it reported them
+ *   cacheReported  whether the provider reported a cached count at all
+ *   firstIn        the first step's prompt tokens (nothing is cached on the first step of a turn)
+ * → { usd, estimated, cachedTokens } — or null when there is no price (never a misleading $0).
+ */
+export function turnCost({ input = 0, cached = 0, cacheReported = false, firstIn = 0, price, assumedShare } = {}) {
+  if (!price || !Number.isFinite(price.input)) return null;
+  // The row's own assumption wins (providers cache differently), else the 90% default.
+  const share = Number.isFinite(assumedShare) ? assumedShare
+    : Number.isFinite(price.assumedCacheShare) ? price.assumedCacheShare
+    : ASSUMED_CACHED_SHARE;
+  const sent = Math.max(0, Number(input) || 0);
+  let cachedTokens;
+  let estimated = false;
+  if (cacheReported) {
+    cachedTokens = Math.min(sent, Math.max(0, Number(cached) || 0));
+  } else {
+    cachedTokens = Math.round(Math.min(1, Math.max(0, share)) * Math.max(0, sent - Math.max(0, Number(firstIn) || 0)));
+    estimated = cachedTokens > 0;
+  }
+  const cachedRate = Number.isFinite(price.cachedInput) ? price.cachedInput : price.input; // no cache price → no discount
+  const usd = ((sent - cachedTokens) * price.input + cachedTokens * cachedRate) / 1e6;
+  return { usd, estimated, cachedTokens };
+}
+
+/** "$1.23", "$0.123", "$0.0042"; "~" in front when the cached share was assumed. */
+export function formatUsd(usd, { estimated = false } = {}) {
+  if (!Number.isFinite(usd)) return "";
+  const v = Math.max(0, usd);
+  const s = v >= 1 ? v.toFixed(2) : v >= 0.01 ? v.toFixed(3) : v > 0 ? v.toFixed(4) : "0";
+  return `${estimated ? "~" : ""}$${s}`;
+}
+
+// ---------------------------------------------------------------------------------------------
+// checking a price table (the published one, before it is applied)
+// ---------------------------------------------------------------------------------------------
+
+const ROW_FIELDS = new Set(["provider", "host", "url", "model", "input", "cachedInput", "output", "cacheWrite", "assumedCacheShare", "source", "checkedAt", "remove"]);
+const price = (v) => v === null || (typeof v === "number" && Number.isFinite(v) && v >= 0 && v <= MAX_PRICE);
+
+/**
+ * Check a price table (the shape PRICE_TABLE has; a bare array of rows is accepted too).
+ * → { ok, version, rows, removes, warnings } | { ok: false, problem }.
+ * A row with "remove": true deletes that server + model — nothing is ever deleted otherwise.
+ */
+export function validatePriceTable(input) {
+  let doc = input;
+  if (typeof input === "string") {
+    const src = input.replace(/^[ \t]*\/\/.*$/gm, "");
+    if (!src.trim()) return { ok: false, empty: true, problem: "nothing was pasted." };
+    try {
+      doc = JSON.parse(src);
+    } catch (e) {
+      return { ok: false, problem: `that is not valid JSON — ${String(e?.message ?? e).replace(/\s*in JSON at position \d+.*$/, "")}.` };
+    }
+  }
+  const list = Array.isArray(doc) ? doc : doc?.prices;
+  if (!Array.isArray(list)) return { ok: false, problem: 'expected { "prices": [ … ] } or a list of rows.' };
+  if (list.length === 0) return { ok: false, problem: "the table has no rows." };
+  if (list.length > MAX_PRICE_ROWS) return { ok: false, problem: `${list.length} rows — at most ${MAX_PRICE_ROWS}.` };
+  const version = !Array.isArray(doc) && doc.version != null ? String(doc.version).slice(0, 40) : "";
+  const rows = [];
+  const removes = [];
+  const warnings = [];
+  const seen = new Set();
+  for (let i = 0; i < list.length; i++) {
+    const r = list[i];
+    const at = `row ${i + 1}`;
+    if (!r || typeof r !== "object" || Array.isArray(r)) return { ok: false, problem: `${at} is not an object.` };
+    const host = hostOf(r.host ?? r.url);
+    const model = typeof r.model === "string" ? r.model.trim() : "";
+    if (!host) return { ok: false, problem: `${at} needs "host" (or "url") — the server it is priced on.` };
+    if (!model || model.length > 120) return { ok: false, problem: `${at} needs "model" (at most 120 characters).` };
+    const key = priceKey(host, model);
+    if (seen.has(key)) return { ok: false, problem: `${at}: ${host} ${model} appears twice.` };
+    seen.add(key);
+    const extra = Object.keys(r).filter((k) => !ROW_FIELDS.has(k));
+    if (extra.length) warnings.push(`${at} (${model}): ignored ${extra.map((k) => `"${k}"`).join(", ")}`);
+    if (r.remove === true) {
+      removes.push({ host, model });
+      continue;
+    }
+    if (!(typeof r.input === "number" && price(r.input))) {
+      return { ok: false, problem: `${at} (${model}): "input" must be a number of USD per 1M tokens, 0 to ${MAX_PRICE}.` };
+    }
+    for (const f of ["cachedInput", "output", "cacheWrite"]) {
+      if (r[f] !== undefined && !price(r[f])) return { ok: false, problem: `${at} (${model}): "${f}" must be a number 0 to ${MAX_PRICE}, or null.` };
+    }
+    if (r.assumedCacheShare !== undefined && !(typeof r.assumedCacheShare === "number" && r.assumedCacheShare >= 0 && r.assumedCacheShare <= 1)) {
+      return { ok: false, problem: `${at} (${model}): "assumedCacheShare" must be a number from 0 to 1 (0.9 = 90%).` };
+    }
+    if (typeof r.cachedInput === "number" && r.cachedInput > r.input) warnings.push(`${at} (${model}): cachedInput is MORE than input — check it`);
+    rows.push({
+      ...(typeof r.provider === "string" && r.provider.trim() ? { provider: r.provider.trim().slice(0, 60) } : {}),
+      host,
+      model,
+      input: r.input,
+      cachedInput: r.cachedInput ?? null,
+      output: r.output ?? null,
+      ...(typeof r.cacheWrite === "number" ? { cacheWrite: r.cacheWrite } : {}),
+      ...(typeof r.assumedCacheShare === "number" ? { assumedCacheShare: r.assumedCacheShare } : {}),
+      ...(typeof r.source === "string" && /^https?:\/\//.test(r.source) ? { source: r.source.slice(0, 300) } : {}),
+      ...(typeof r.checkedAt === "string" && !Number.isNaN(Date.parse(r.checkedAt)) ? { checkedAt: r.checkedAt.slice(0, 30) } : {}),
+    });
+  }
+  return { ok: true, version, rows, removes, warnings };
+}
+
+const COMPARED = ["input", "cachedInput", "output", "cacheWrite", "assumedCacheShare", "provider"];
+
+/** What applying `incoming` to `current` would do. → { added, changed:[{row, was, fields}], unchanged, removed, missingRemoves } */
+export function diffPrices(current, incoming, removes = []) {
+  const now = new Map((current ?? []).map((r) => [priceKey(r.host, r.model), r]));
+  const added = [];
+  const changed = [];
+  let unchanged = 0;
+  for (const r of incoming) {
+    const was = now.get(priceKey(r.host, r.model));
+    if (!was) {
+      added.push(r);
+      continue;
+    }
+    const fields = COMPARED.filter((f) => (r[f] ?? null) !== (was[f] ?? null) && !(f === "provider" && r[f] == null));
+    if (fields.length) changed.push({ row: r, was, fields });
+    else unchanged++;
+  }
+  const removed = removes.filter((x) => now.has(priceKey(x.host, x.model)));
+  const missingRemoves = removes.filter((x) => !now.has(priceKey(x.host, x.model)));
+  return { added, changed, unchanged, removed, missingRemoves };
+}
+
+/** The diff as lines, for the "apply? [y/N]" question. */
+export function diffLines(d) {
+  const p = (v) => (v == null ? "—" : `$${v}`);
+  const out = [];
+  for (const r of d.added) out.push(`+ ${r.host}  ${r.model}  in ${p(r.input)} · cached ${p(r.cachedInput)}`);
+  const pct = (v) => (v == null ? "—" : `${Math.round(v * 100)}%`);
+  const show = (f, v) => (f === "assumedCacheShare" ? pct(v) : p(v));
+  for (const c of d.changed) out.push(`~ ${c.row.host}  ${c.row.model}  ${c.fields.map((f) => (f === "provider" ? `provider → ${c.row.provider}` : `${f} ${show(f, c.was[f])} → ${show(f, c.row[f])}`)).join(", ")}`);
+  for (const r of d.removed) out.push(`- ${r.host}  ${r.model}  (removed)`);
+  out.push(`${d.added.length} new · ${d.changed.length} changed · ${d.unchanged} unchanged${d.removed.length ? ` · ${d.removed.length} removed` : ""}`);
+  return out;
+}
+
+// ---------------------------------------------------------------------------------------------
+// /price
+// ---------------------------------------------------------------------------------------------
+
+/**
+ * The table for /price, grouped by server, newest-first nowhere — alphabetical, so a model is easy
+ * to find. `current` = { url, model } of the coder in use: its row is marked "▸".
+ * Columns: model · input · cached · output (USD per 1M). Fits `width` (80 on a server over SSH).
+ */
+export function priceTableLines(rows, { width = 80, current = null, version = "" } = {}) {
+  const cur = current ? findPrice(rows, current.url, current.model) : null;
+  const money = (v) => (v == null ? "—" : `$${Number(v) < 0.1 && v !== 0 ? Number(v).toString() : Number(v).toFixed(2)}`);
+  const numW = 9;
+  const modelW = Math.max(12, Math.min(34, width - 4 - 2 - numW * 3));
+  const cut = (s, w) => (s.length > w ? s.slice(0, w - 1) + "…" : s.padEnd(w));
+  const out = [`USD per 1M tokens${version ? ` · table v${version}` : ""}`];
+  out.push(`  ${"model".padEnd(modelW)}${"input".padStart(numW)}${"cached".padStart(numW)}${"output".padStart(numW)}`);
+  const hosts = [...new Set(rows.map((r) => r.host))].sort();
+  for (const h of hosts) {
+    const group = rows.filter((r) => r.host === h).sort((a, b) => a.model.localeCompare(b.model));
+    out.push(`${h}${group[0]?.provider ? `  (${group[0].provider})` : ""}`);
+    for (const r of group) {
+      out.push(`${r === cur ? "▸ " : "  "}${cut(r.model, modelW)}${money(r.input).padStart(numW)}${money(r.cachedInput).padStart(numW)}${money(r.output).padStart(numW)}`);
+    }
+  }
+  return out;
+}
+
+// ---------------------------------------------------------------------------------------------
+// THE ASSUMED-CACHE-SHARE TABLE (#323 follow-up) — its own table so the admin can review and
+// publish it on its own (Deploy app → "Cache shares" → Update to API), and users can read it with
+// /prices. Made FROM the price table (the rows that have a cache price), so the two cannot
+// disagree.
+// ---------------------------------------------------------------------------------------------
+
+/** Why each provider's share is what it is — shown beside the number, so it can be reviewed. */
+export const CACHE_SHARE_WHY = Object.freeze({
+  "api.moonshot.ai": "automatic prefix caching (Kimi reports cached_tokens)",
+  "api.openai.com": "automatic prefix caching for prompts ≥ 1024 tokens (reports cached_tokens)",
+  "api.anthropic.com": "cached only when the request asks — gu's Claude path does (reports cache reads)",
+  "ollama.com": "lists cache prices; whether it reports a count is not yet verified",
+});
+
+export const CACHE_SHARE_TABLE = Object.freeze({
+  gu: "cache-shares",
+  version: PRICE_TABLE_VERSION,
+  publishedAt: PRICE_TABLE.publishedAt,
+  note: "The share of a step's prompt (after a turn's first step) assumed served from the provider's cache, used ONLY when the provider does not report its own cached count. 0.9 = 90%.",
+  shares: PRICE_TABLE.prices
+    .filter((r) => r.cachedInput != null)
+    .map((r) => ({ provider: r.provider, host: r.host, model: r.model, assumedCacheShare: r.assumedCacheShare ?? ASSUMED_CACHED_SHARE, why: CACHE_SHARE_WHY[r.host] ?? "" })),
+});
+
+/** Check a cache-share table → { ok, version, shares } | { ok: false, problem }. */
+export function validateCacheShareTable(input) {
+  let doc = input;
+  if (typeof input === "string") {
+    try {
+      doc = JSON.parse(input.replace(/^[ \t]*\/\/.*$/gm, ""));
+    } catch (e) {
+      return { ok: false, problem: `that is not valid JSON — ${String(e?.message ?? e).replace(/\s*in JSON at position \d+.*$/, "")}.` };
+    }
+  }
+  const list = Array.isArray(doc) ? doc : doc?.shares;
+  if (!Array.isArray(list) || list.length === 0) return { ok: false, problem: 'expected { "shares": [ … ] } with at least one row.' };
+  if (list.length > MAX_PRICE_ROWS) return { ok: false, problem: `${list.length} rows — at most ${MAX_PRICE_ROWS}.` };
+  const seen = new Set();
+  const shares = [];
+  for (const [i, r] of list.entries()) {
+    const at = `row ${i + 1}`;
+    const host = hostOf(r?.host ?? r?.url);
+    const model = typeof r?.model === "string" ? r.model.trim() : "";
+    if (!host || !model) return { ok: false, problem: `${at} needs "host" and "model".` };
+    if (!(typeof r.assumedCacheShare === "number" && r.assumedCacheShare >= 0 && r.assumedCacheShare <= 1)) {
+      return { ok: false, problem: `${at} (${model}): "assumedCacheShare" must be a number from 0 to 1 (0.9 = 90%).` };
+    }
+    const key = priceKey(host, model);
+    if (seen.has(key)) return { ok: false, problem: `${at}: ${host} ${model} appears twice.` };
+    seen.add(key);
+    shares.push({
+      ...(typeof r.provider === "string" && r.provider.trim() ? { provider: r.provider.trim().slice(0, 60) } : {}),
+      host,
+      model,
+      assumedCacheShare: r.assumedCacheShare,
+      ...(typeof r.why === "string" && r.why.trim() ? { why: r.why.trim().slice(0, 200) } : {}),
+    });
+  }
+  const version = !Array.isArray(doc) && doc.version != null ? String(doc.version).slice(0, 40) : "";
+  return { ok: true, version, shares };
+}
+
+/**
+ * The cache table in /prices: the share each model is assumed to cache — THIS ACCOUNT's (its price rows, what its
+ * estimates use) beside the one gu PUBLISHED (when the API has one), marking where they differ.
+ * Fits `width`; the coder in use is marked "▸".
+ */
+export function cacheShareLines({ yours = [], published = null, width = 80, current = null } = {}) {
+  const pub = new Map((published?.shares ?? []).map((s) => [priceKey(s.host, s.model), s.assumedCacheShare]));
+  const mine = (yours ?? []).filter((r) => r.cachedInput != null || pub.has(priceKey(r.host, r.model)));
+  const cur = current ? findPrice(mine, current.url, current.model) : null;
+  const pct = (v) => (Number.isFinite(v) ? `${Math.round(v * 100)}%` : "—");
+  const colW = 8;
+  const modelW = Math.max(12, Math.min(34, width - 4 - 2 - colW * 2 - 2));
+  const cut = (s, w) => (s.length > w ? s.slice(0, w - 1) + "…" : s.padEnd(w));
+  const out = [];
+  out.push(`  ${"model".padEnd(modelW)}${"yours".padStart(colW)}${published ? "gu".padStart(colW) : ""}`);
+  const keys = new Set([...mine.map((r) => priceKey(r.host, r.model)), ...pub.keys()]);
+  const rows = [...keys].map((k) => {
+    const r = mine.find((x) => priceKey(x.host, x.model) === k);
+    const s = published?.shares?.find((x) => priceKey(x.host, x.model) === k);
+    return { host: r?.host ?? s.host, model: r?.model ?? s.model, yours: r ? (Number.isFinite(r.assumedCacheShare) ? r.assumedCacheShare : ASSUMED_CACHED_SHARE) : undefined, gu: pub.get(k), row: r };
+  });
+  for (const h of [...new Set(rows.map((r) => r.host))].sort()) {
+    out.push(h);
+    for (const r of rows.filter((x) => x.host === h).sort((a, b) => a.model.localeCompare(b.model))) {
+      const differs = published && r.gu !== undefined && r.yours !== undefined && Math.abs(r.gu - r.yours) > 1e-9;
+      out.push(`${r.row && r.row === cur ? "▸ " : "  "}${cut(r.model, modelW)}${pct(r.yours).padStart(colW)}${published ? pct(r.gu).padStart(colW) : ""}${differs ? " *" : ""}`);
+    }
+  }
+  return out;
+}
+
+// ---------------------------------------------------------------------------------------------
+// "NEW PRICES UPDATED <date>" (#323): gu checks the hosted API's GET /api/get-price-and-cache-table
+// (the newest tables the admin published from the Deploy app); when they are newer than what this
+// account last applied, the notice row offers them, and a click writes both into the user's Mongo.
+// ---------------------------------------------------------------------------------------------
+
+/** Is the published stamp newer than the one this account applied? ("" applied = never.) */
+export function hasNewerPublished(appliedAt, publishedAt) {
+  const p = Date.parse(publishedAt ?? "");
+  if (!Number.isFinite(p)) return false;
+  const a = Date.parse(appliedAt ?? "");
+  return !Number.isFinite(a) || p > a;
+}
+
+/** The notice: "new prices updated 1 Oct 2026". */
+export function priceUpdateLabel(publishedAt) {
+  const d = new Date(publishedAt);
+  if (Number.isNaN(d.getTime())) return "new prices updated";
+  const m = ["Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"][d.getUTCMonth()];
+  return `new prices updated ${d.getUTCDate()} ${m} ${d.getUTCFullYear()}`;
+}
+
+/**
+ * The published tables onto this account's rows → what to write.
+ *   · the published PRICE table's rows replace the same server + model here (others are kept —
+ *     a self-hosted server priced by hand stays);
+ *   · the published CACHE table's share is set on each matching row (published price rows and the
+ *     account's own);
+ *   · nothing is deleted.
+ * → { ok, rows: the rows that change (to PUT), diff, version, publishedAt } | { ok: false, problem }
+ */
+export function mergePublishedTables(current, cloud) {
+  const pub = cloud ?? {};
+  const priceRows = [];
+  if (pub.prices) {
+    const c = validatePriceTable(pub.prices);
+    if (!c.ok) return { ok: false, problem: `the published price table is not usable — ${c.problem}` };
+    priceRows.push(...c.rows);
+  }
+  let shares = [];
+  if (pub.cacheShares) {
+    const c = validateCacheShareTable(pub.cacheShares);
+    if (!c.ok) return { ok: false, problem: `the published cache table is not usable — ${c.problem}` };
+    shares = c.shares;
+  }
+  if (!priceRows.length && !shares.length) return { ok: false, problem: "nothing has been published yet." };
+  const share = new Map(shares.map((s) => [priceKey(s.host, s.model), s.assumedCacheShare]));
+  const byKey = new Map((current ?? []).map((r) => [priceKey(r.host, r.model), { ...r }]));
+  for (const r of priceRows) {
+    const was = byKey.get(priceKey(r.host, r.model));
+    // A published price row without its own share keeps the one this account has, until the cache
+    // table says otherwise.
+    byKey.set(priceKey(r.host, r.model), { ...r, ...(r.assumedCacheShare == null && was?.assumedCacheShare != null ? { assumedCacheShare: was.assumedCacheShare } : {}) });
+  }
+  for (const [k, row] of byKey) if (share.has(k) && row.cachedInput != null) row.assumedCacheShare = share.get(k);
+  const merged = [...byKey.values()];
+  const diff = diffPrices(current ?? [], merged);
+  return {
+    ok: true,
+    rows: [...diff.added, ...diff.changed.map((c) => c.row)],
+    diff,
+    version: pub.prices?.version || pub.cacheShares?.version || "",
+    publishedAt: pub.publishedAt || [pub.prices?.publishedAt, pub.cacheShares?.publishedAt].filter(Boolean).sort().at(-1) || "",
+  };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tiens.nguyen/gu-cli",
-  "version": "1.0.783",
+  "version": "1.0.785",
   "description": "Gu CLI — the gu terminal plus the local worker that runs agent / OCR / PDF / embedding jobs on your Mac (Ollama / MLX / OpenAI-compatible).",
   "type": "module",
   "license": "MIT",
@@ -41,7 +41,7 @@
     "check:image": "node scripts/image-paste-check.mjs",
     "check:image-clipboard": "node scripts/image-paste-check.mjs --clipboard",
     "test:presets": "node --test tests/open-presets.test.mjs tests/preset-safety.test.mjs tests/preset-more.test.mjs tests/preset-apply.test.mjs tests/preset-full.test.mjs tests/presets-transfer.test.mjs tests/preset-editor.test.mjs tests/load-preset-paste.test.mjs",
-    "test:skills": "python3 scripts/py-tap.py tests/test_skills_mcp_turn.py tests/test_hooks_turn.py tests/test_mcp_client.py && node --test tests/skills.test.mjs tests/mcp-config.test.mjs tests/hooks-config.test.mjs tests/slash-menu.test.mjs tests/conversation-archive.test.mjs",
+    "test:skills": "python3 scripts/py-tap.py tests/test_skills_mcp_turn.py tests/test_hooks_turn.py tests/test_claude_hooks.py tests/test_mcp_client.py && node --test tests/skills.test.mjs tests/mcp-config.test.mjs tests/hooks-config.test.mjs tests/switch-skill.test.mjs tests/slash-menu.test.mjs tests/conversation-archive.test.mjs",
     "capture:turn": "GONEXT_OLLAMA1_LIVE=1 node scripts/capture-turn-fixture.mjs",
     "test:bearer": "node --test tests/bearer-routing.test.mjs tests/bearer-verify.test.mjs",
     "test:bearer-e2e": "bash scripts/bearer-e2e.sh"
@@ -69,6 +69,7 @@
     "image-capable-coders.json",
     "preset-editor.mjs",
     "preset-apply.mjs",
+    "model-prices.mjs",
     "device-login.mjs",
     "daemon-control.mjs",
     "log-policy.mjs",
@@ -108,6 +109,7 @@
     "powershell-alias.mjs",
     "install-path.mjs",
     "skills.mjs",
+    "skill-source.mjs",
     "mcp-config.mjs",
     "mcp-command.mjs",
     "hooks-config.mjs",

package/skill-source.mjs

@@ -0,0 +1,60 @@
+/**
+ * WHOSE SKILLS THIS FOLDER USES — gu's or Claude Code's (task #325, /switch-skill).
+ *
+ *   "gu"      ~/.gonext  and  <project>/.gonext     (the default; a folder that never chose)
+ *   "claude"  ~/.claude  and  <project>/.claude     Claude Code's own files, read where they are
+ *
+ * One choice covers skills, MCP servers and hooks, because they depend on each other: a skill names
+ * an MCP server's tools, and the hooks feed the same database that server reads. Switching one of
+ * the three alone would leave them talking about different things.
+ *
+ * ONE-WAY. gu reads Claude Code's setup; Claude Code is never expected to read gu's. So nothing of
+ * gu's own is written into Claude's files: which project servers and hooks you approved, and the
+ * allow rules, stay in ~/.gonext whichever source is chosen.
+ *
+ * PER FOLDER, IN THE FOLDER'S SESSION FILE. The terminal writes it; the worker — a different
+ * process, which builds each turn's skills, servers and hooks — reads the same file. Every reader
+ * in this package resolves the source through readSkillSource, so the banner and the turn cannot
+ * disagree about which setup is in use.
+ */
+import { createHash } from "node:crypto";
+import { readFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+
+export const SKILL_SOURCES = ["gu", "claude"];
+export const DEFAULT_SKILL_SOURCE = "gu";
+/** The session file's key. */
+export const SKILL_SOURCE_KEY = "skillSource";
+
+export const normalizeSkillSource = (v) => (v === "claude" ? "claude" : DEFAULT_SKILL_SOURCE);
+
+/** The folder each source keeps its files in — under the home directory and under the project. */
+export const sourceDirName = (source) => (normalizeSkillSource(source) === "claude" ? ".claude" : ".gonext");
+
+/** What a picker and a status line call it. */
+export const sourceLabel = (source) => (normalizeSkillSource(source) === "claude" ? "Claude's skills" : "gu's skills");
+
+/** The terminal's per-folder session file — the same name gu-repl.mjs uses. */
+export function sessionFileFor(cwd, home = homedir()) {
+  const hash = createHash("sha256").update(String(cwd)).digest("hex").slice(0, 32);
+  return join(home, ".gonext", "sessions", `${hash}.json`);
+}
+
+/**
+ * This folder's choice. No folder, no session file, a file that cannot be read, any other value:
+ * gu's — the behaviour before there was a choice, and never an error.
+ */
+export function readSkillSource(cwd, home = homedir()) {
+  if (!cwd) return DEFAULT_SKILL_SOURCE;
+  try {
+    const raw = JSON.parse(readFileSync(sessionFileFor(cwd, home), "utf8"));
+    return normalizeSkillSource(raw?.[SKILL_SOURCE_KEY]);
+  } catch {
+    return DEFAULT_SKILL_SOURCE;
+  }
+}
+
+/** `source` when a caller names one, else the folder's own. */
+export const resolveSkillSource = ({ source, cwd, home = homedir() } = {}) =>
+  source ? normalizeSkillSource(source) : readSkillSource(cwd, home);

package/skills.mjs

@@ -4,6 +4,10 @@
  *   ~/.gonext/skills/<name>/SKILL.md        yours, every folder
  *   <project>/.gonext/skills/<name>/SKILL.md this project only
  *
+ * …or Claude Code's own, when the folder chose them with /switch-skill (#325, skill-source.mjs):
+ *   ~/.claude/skills/<name>/SKILL.md  and  <project>/.claude/skills/<name>/SKILL.md
+ * The same file in the same layout — only the folder differs, so nothing is converted.
+ *
  * A SKILL.md is YAML frontmatter (name, description) and a body of instructions. Only the name and
  * description go into every prompt; the body is read when the agent calls use_skill(name) or the
  * user types /<name> — never pasted into every turn. Same split as Claude Code, and for the same
@@ -24,16 +28,17 @@
 import { readdirSync, readFileSync, statSync } from "node:fs";
 import { homedir } from "node:os";
 import { join } from "node:path";
+import { resolveSkillSource, sourceDirName } from "./skill-source.mjs";
 
 export const SKILL_FILE = "SKILL.md";
 /** Claude Code's rule: lowercase letters, digits and hyphens, at most 64. It is also a slash command. */
 export const SKILL_NAME_RE = /^[a-z0-9][a-z0-9-]{0,63}$/;
 
-export function userSkillsDir(home = homedir()) {
-  return join(home, ".gonext", "skills");
+export function userSkillsDir(home = homedir(), source = "gu") {
+  return join(home, sourceDirName(source), "skills");
 }
-export function projectSkillsDir(cwd) {
-  return join(cwd, ".gonext", "skills");
+export function projectSkillsDir(cwd, source = "gu") {
+  return join(cwd, sourceDirName(source), "skills");
 }
 
 /** Strip one pair of matching quotes. */
@@ -138,13 +143,17 @@ function scanDir(dir, scope) {
  * the built-in wins, and the skill is still usable by the agent, just not as a slash command —
  * that is `slash: false`.
  *
- * → { skills: [{ name, description, path, dir, scope, slash }], warnings: string[] }
+ * `source` = whose skills ("gu" | "claude"); left out, it is the folder's own choice (/switch-skill).
+ * Only that source's skills are listed — the two are never mixed.
+ *
+ * → { skills: [{ name, description, path, dir, scope, slash, source }], warnings: string[], source }
  */
-export function discoverSkills({ cwd = process.cwd(), home = homedir(), reserved = [] } = {}) {
-  const user = scanDir(userSkillsDir(home), "user");
+export function discoverSkills({ cwd = process.cwd(), home = homedir(), reserved = [], source } = {}) {
+  const src = resolveSkillSource({ source, cwd, home });
+  const user = scanDir(userSkillsDir(home, src), "user");
   const project =
-    cwd && projectSkillsDir(cwd) !== userSkillsDir(home)
-      ? scanDir(projectSkillsDir(cwd), "project")
+    cwd && projectSkillsDir(cwd, src) !== userSkillsDir(home, src)
+      ? scanDir(projectSkillsDir(cwd, src), "project")
       : { skills: [], warnings: [] };
   const byName = new Map();
   for (const s of user.skills) byName.set(s.name, s);
@@ -152,17 +161,20 @@ export function discoverSkills({ cwd = process.cwd(), home = homedir(), reserved
   const taken = new Set(reserved.map((r) => r.replace(/^\//, "")));
   const skills = [...byName.values()]
     .sort((a, b) => a.name.localeCompare(b.name))
-    .map((s) => ({ ...s, slash: !taken.has(s.name) }));
-  return { skills, warnings: [...user.warnings, ...project.warnings] };
+    .map((s) => ({ ...s, slash: !taken.has(s.name), source: src }));
+  return { skills, warnings: [...user.warnings, ...project.warnings], source: src };
 }
 
 /** What the worker hands the agent for one turn: enough to list them and to read one. */
 export function skillsForTurn(opts) {
-  return discoverSkills(opts).skills.map(({ name, description, path, dir }) => ({
+  // `source` goes along only for Claude's: the agent then reads the skill as one written for
+  // Claude Code's tools (gu_skills.py). gu's own keep the shape they always had.
+  return discoverSkills(opts).skills.map(({ name, description, path, dir, source }) => ({
     name,
     description,
     path,
     dir,
+    ...(source === "claude" ? { source } : {}),
   }));
 }