altalandi-mcp 0.3.0 → 0.6.0

package/README.md

@@ -1,71 +1,102 @@
-# altalandi-mcp
-
-An [MCP](https://modelcontextprotocol.io) server that exposes
-[Altalandi](https://altalandi.is), native-Icelandic refinement with a
-meaning-preservation check, as a tool any MCP client can call. stdio transport.
-
-## Set up (Claude Code or Codex)
-
-Connect this computer once. This opens altalandi.is, you approve, and the key
-is stored locally. You never copy it:
-
-```bash
-npx altalandi login
-```
-
-Then add the server. No key goes into any config file; the server reads the
-one `altalandi login` stored:
-
-```bash
-claude mcp add altalandi -s user -- npx -y altalandi-mcp   # Claude Code
-codex mcp add altalandi -- npx -y altalandi-mcp            # Codex
-```
-
-Ask for Icelandic and mention Altalandi, e.g. *"Write this in proper Icelandic
-with Altalandi."* The agent calls the **`refine_icelandic`** tool.
-
-### Without `altalandi login` (CI, services, other clients)
-
-Set `ALTALANDI_API_KEY` in the server's environment, from your host's secret
-manager. It takes precedence over a stored login. Mint a key at
-<https://altalandi.is/portal>. Never commit a plaintext key in MCP JSON.
-
-```json
-{ "mcpServers": { "altalandi": { "command": "npx", "args": ["-y", "altalandi-mcp"] } } }
-```
-
-## The tool
-
-`refine_icelandic({ text, domain?, register?, sourceLang? })` returns the native
-Icelandic text, a 0–100 nativeness score, an explicit meaning verdict, and every
-warning returned by the API.
-
-- `domain`: `general` \| `marketing` \| `data-analysis` \| `childrens-fiction`
-- `register`: `formal` \| `neutral` \| `warm`
-- `sourceLang`: `auto` \| `en` \| `is`
-
-**Meaning guarantee:** on Icelandic input where the rewrite can't be verified to
-preserve meaning, the tool returns the **original unchanged** and flags it,
-never a silent change.
-
-Only **meaning preserved** is a verified result. **MEANING UNVERIFIED** means the
-check did not run or could not complete; review that output before use. API
-warnings are included under a clear `Warnings:` section in the tool's result.
-
-## Config
-
-| env | default | purpose |
-|-----|---------|---------|
-| `ALTALANDI_API_KEY` | (the key from `altalandi login`) | your key (Bearer) |
-| `ALTALANDI_CONFIG_DIR` | `%APPDATA%\altalandi` / `~/.config/altalandi` | where `altalandi login` stored it |
-| `ALTALANDI_BASE_URL` | `https://altalandi.is/api` | API base (override for self-hosting) |
-
-Each API request has a fixed 300-second deadline, including the response body,
-so a stalled provider cannot leave the tool hanging.
-
-## Cost
-
-Calls are paid from the account's prepaid credit in krónur (a new account
-starts with trial credit). See <https://altalandi.is/verd>.
-
-MIT licensed. Requires Node ≥ 18.
+# altalandi-mcp
+
+An [MCP](https://modelcontextprotocol.io) server that exposes
+[Altalandi](https://altalandi.is), native-Icelandic refinement with a
+meaning-preservation check, as a tool any MCP client can call. stdio transport.
+
+## Set up (Claude Code or Codex)
+
+Connect this computer once. This opens altalandi.is, you approve, and the key
+is stored locally. You never copy it:
+
+```bash
+npx altalandi login
+```
+
+Then add the server. No key goes into any config file; the server reads the
+one `altalandi login` stored:
+
+```bash
+claude mcp add altalandi -s user -- npx -y altalandi-mcp   # Claude Code
+codex mcp add altalandi -- npx -y altalandi-mcp            # Codex
+```
+
+Ask for Icelandic and mention Altalandi, e.g. *"Write this in proper Icelandic
+with Altalandi."* The agent calls the **`refine_icelandic`** tool.
+
+### Without `altalandi login` (CI, services, other clients)
+
+Set `ALTALANDI_API_KEY` in the server's environment, from your host's secret
+manager. It takes precedence over a stored login. Mint a key at
+<https://altalandi.is/portal>. Never commit a plaintext key in MCP JSON.
+
+```json
+{ "mcpServers": { "altalandi": { "command": "npx", "args": ["-y", "altalandi-mcp"] } } }
+```
+
+## The tool
+
+`refine_icelandic({ text, domain?, register?, sourceLang?, report? })` returns two
+parts. The first is one Markdown block: the verdict and nativeness score, the text
+before and after (Fyrir / Eftir), a numbered list of changes with their reasons,
+why a rewrite was refused if it was, and what the call cost with the balance and
+free units left (Kostnaður). The second is the full refined text to apply. The
+tool tells the agent to show the block to you as it is after every call, so you see
+what changed and what it cost in the terminal or the editor, not only on the website.
+
+- `domain`: `general` \| `marketing` \| `data-analysis` \| `childrens-fiction`
+- `register`: `formal` \| `neutral` \| `warm`
+- `sourceLang`: `auto` \| `en` \| `is`
+- `noStore`: `true` means Altalandi never keeps this text. Otherwise free use (the free
+  daily units) is kept, with personal data scrubbed, to improve the service; paid use only
+  with consent ([privacy](https://altalandi.is/personuvernd#textabanki)).
+- `report`: `true` also writes `./altalandi-reports/altalandi-<time>-<id>.md`
+  (input, output, every change with its reason and layer, warnings, verdict).
+  Default: on when `ALTALANDI_REPORT=1`. Reports contain the text, so they are opt-in.
+
+**Meaning guarantee:** on Icelandic input where the rewrite can't be verified to
+preserve meaning, the tool returns the **original unchanged** and flags it,
+never a silent change.
+
+## Proofreading
+
+`proofread_icelandic({ text, suggestions?, minPrecision?, noStore? })` fixes only
+proven errors in Icelandic you wrote (punctuation, word boundaries, a misspelt word
+one slip from the right one) and keeps your wording. Everything else comes back as
+numbered **suggestions**, each with its reason and, when known, how sure it is. The
+agent shows you each one and applies only those you accept.
+
+- `suggestions`: `offer` (default: you choose) \| `apply` (the kinds of suggestion
+  measured right at least `minPrecision` of the time are applied and listed; the rest
+  are offered) \| `off` (only the safe fixes).
+- `minPrecision`: 0.5 to 0.99, default 0.9. A suggestion with a digit, or one that
+  changes a name, is never applied unasked.
+
+Then `record_suggestion_decisions({ resultId, decisions })` tells Altalandi which
+suggestions you used or ignored (numbers only, no text, free). That is how the
+suggestions get better.
+
+Only **meaning preserved** is a verified result. **MEANING UNVERIFIED** means the
+check did not run or could not complete; review that output before use. API
+warnings are included under a clear `Warnings:` section in the tool's result.
+
+## Config
+
+| env | default | purpose |
+|-----|---------|---------|
+| `ALTALANDI_API_KEY` | (the key from `altalandi login`) | your key (Bearer) |
+| `ALTALANDI_CONFIG_DIR` | `%APPDATA%\altalandi` / `~/.config/altalandi` | where `altalandi login` stored it |
+| `ALTALANDI_BASE_URL` | `https://altalandi.is/api` | API base (override for self-hosting) |
+| `ALTALANDI_REPORT` | — | `1` = write a report for every call |
+| `ALTALANDI_REPORT_DIR` | `./altalandi-reports` (the server's working folder) | where reports go |
+
+Each API request has a fixed 300-second deadline, including the response body,
+so a stalled provider cannot leave the tool hanging.
+
+## Cost
+
+Every account gets 2,000 free units a day on the standard writer (about 2,000
+words); past that, calls are paid from prepaid credit in krónur, and a new account
+also starts with 500 kr. of trial credit. See <https://altalandi.is/verd>.
+
+MIT licensed. Requires Node ≥ 18.

package/api-client.mjs

@@ -52,3 +52,34 @@ export async function requestRefine(
     clearTimeoutImpl(timeout);
   }
 }
+
+/** The account behind the key (balance, free units), or null. Best-effort:
+ *  it only fills the cost lines of the review block. */
+export async function requestMe(baseUrl, apiKey, { fetchImpl = globalThis.fetch } = {}) {
+  try {
+    const response = await fetchImpl(`${baseUrl}/v1/me`, {
+      headers: { authorization: `Bearer ${apiKey}`, accept: "application/json" },
+      signal: AbortSignal.timeout(15_000),
+    });
+    return response.ok ? await response.json() : null;
+  } catch {
+    return null;
+  }
+}
+
+/** Report what the person chose for each proofreading suggestion (free; no
+ *  model runs; no text is sent). Returns {ok, recorded, refused} or {ok: false, error}. */
+export async function requestSuggestionDecisions(baseUrl, apiKey, body, { fetchImpl = globalThis.fetch } = {}) {
+  try {
+    const response = await fetchImpl(`${baseUrl}/v1/suggestions`, {
+      method: "POST",
+      headers: { "content-type": "application/json", authorization: `Bearer ${apiKey}` },
+      body: JSON.stringify(body),
+      signal: AbortSignal.timeout(15_000),
+    });
+    const data = await response.json().catch(() => ({}));
+    return response.ok ? data : { ok: false, error: data.detail || response.statusText };
+  } catch (error) {
+    return { ok: false, error: error.message };
+  }
+}

package/device.mjs

@@ -0,0 +1,80 @@
+// Sign-in from inside the MCP server, for clients where nobody opens a
+// terminal (Claude Desktop). The same device login as `npx altalandi login`:
+// the server asks for a short code, the tool result gives the person a link,
+// they sign in or sign up at altalandi.is and approve, and the server stores
+// the key where the CLI keeps it (key.mjs), so one login serves both.
+//
+// One login runs at a time; while it is pending, every call returns the same
+// link instead of starting another.
+
+import { chmod, mkdir, writeFile } from "node:fs/promises";
+import { hostname } from "node:os";
+import path from "node:path";
+import { configDir } from "./key.mjs";
+
+const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
+let pending = null;   // { link, code, expiresAt }
+
+async function postJson(fetchImpl, url, body) {
+  const res = await fetchImpl(url, {
+    method: "POST",
+    headers: { "content-type": "application/json", accept: "application/json" },
+    body: JSON.stringify(body),
+  });
+  let data = {};
+  try { data = await res.json(); } catch { /* keep {} */ }
+  return { status: res.status, data };
+}
+
+async function save(data, env) {
+  const dir = configDir({ env });
+  await mkdir(dir, { recursive: true });
+  const file = path.join(dir, "credentials.json");
+  await writeFile(file, JSON.stringify(data, null, 2) + "\n", { encoding: "utf8", mode: 0o600 });
+  try { await chmod(file, 0o600); } catch { /* Windows: the profile directory protects it */ }
+  return file;
+}
+
+/**
+ * The link and code for the person to approve. Starts a login if none is
+ * pending; the approval is picked up in the background and saved.
+ * Returns { link, code } or { error }.
+ */
+export async function beginLogin(base, { fetchImpl = globalThis.fetch, env = process.env, client = "Claude Desktop", wait = sleep } = {}) {
+  if (pending && Date.now() < pending.expiresAt) return { link: pending.link, code: pending.code };
+  let start;
+  try {
+    const where = (hostname() || "").split(".")[0].slice(0, 24);
+    start = await postJson(fetchImpl, `${base}/v1/device/start`, { clientName: where ? `${client} á ${where}` : client });
+  } catch (e) {
+    return { error: `Náði ekki sambandi við Altalandi (${e.message}).` };
+  }
+  if (start.status !== 200 || !start.data.deviceCode) {
+    return { error: start.data.detail || `Innskráning fór ekki af stað (HTTP ${start.status}).` };
+  }
+  const { deviceCode, userCode, verificationUriComplete, interval = 3, expiresIn = 600 } = start.data;
+  pending = { link: verificationUriComplete, code: userCode, expiresAt: Date.now() + expiresIn * 1000 };
+  const mine = pending;
+  // Poll in the background until approved, refused or expired.
+  (async () => {
+    while (pending === mine && Date.now() < mine.expiresAt) {
+      await wait(Math.max(1, interval) * 1000);
+      let poll;
+      try { poll = await postJson(fetchImpl, `${base}/v1/device/token`, { deviceCode }); } catch { continue; }
+      if (poll.status === 200 && poll.data.status === "approved") {
+        try {
+          await save({ apiKey: poll.data.apiKey, username: poll.data.username, savedAt: new Date().toISOString() }, env);
+        } catch { /* the next call will offer a new login */ }
+        break;
+      }
+      if (poll.status === 200 && poll.data.status === "pending") continue;
+      if (poll.status === 429) { await wait(10_000); continue; }
+      break;   // expired or refused
+    }
+    if (pending === mine) pending = null;
+  })();
+  return { link: mine.link, code: mine.code };
+}
+
+/** For tests. */
+export function _resetLogin() { pending = null; }

package/format-response.mjs

@@ -53,3 +53,40 @@ export function formatRefineResponse(data) {
 
   return lines.join("\n");
 }
+
+const LABELS = { both: "both checks agree", one: "one check", rule: "rule (BÍN)" };
+
+/** A task=proofread response for an agent: the corrected text, what was fixed,
+ *  the numbered suggestions to offer, and what to do once the person decides. */
+export function formatProofreadResponse(data) {
+  const lines = ["**Altalandi prófarkalestur** (proofreading)", "", "Corrected text (proven errors fixed):", "",
+    String(data?.output ?? ""), ""];
+  const diffs = Array.isArray(data?.diffs) ? data.diffs : [];
+  if (diffs.length) {
+    lines.push("Fixed:");
+    for (const d of diffs.slice(0, 20)) {
+      lines.push(`- „${String(d.before ?? "").trim()}“ → „${String(d.after ?? "").trim()}“ (${d.reason ?? ""})`);
+    }
+    lines.push("");
+  }
+  const suggestions = Array.isArray(data?.suggestions) ? data.suggestions : [];
+  if (suggestions.length) {
+    lines.push("Suggestions — show every one to the person and ask which to apply; apply only those accepted:");
+    suggestions.slice(0, 100).forEach((s, i) => {
+      const label = LABELS[s.agreement] ? ` · ${LABELS[s.agreement]}` : "";
+      lines.push(`${i}. „${s.before}“ → „${s.after}“ · ${s.reason ?? ""}${label}`);
+    });
+    lines.push("", `When the person has decided, call record_suggestion_decisions with resultId ${data?.id} ` +
+      "and a decision (used or ignored) for every number. That is how Altalandi learns which suggestions to trust.");
+  } else {
+    lines.push("No suggestions.");
+  }
+  const unresolved = Array.isArray(data?.unresolved) ? data.unresolved : [];
+  if (unresolved.length) {
+    lines.push("", "Likely errors left as they were (point them out to the person):");
+    for (const u of unresolved.slice(0, 10)) {
+      lines.push(`- ${(u.words || []).join(", ") || String(u.sentence ?? "").slice(0, 120)}: ${u.note ?? ""}`);
+    }
+  }
+  return lines.join("\n");
+}

package/key.mjs

@@ -18,7 +18,10 @@ export function configDir({ env = process.env, home = homedir(), platform = proc
 /** { key, source } where source is "env", "login" or "none". Never throws. */
 export function resolveKey(opts = {}) {
   const env = opts.env ?? process.env;
-  const fromEnv = env.ALTALANDI_API_KEY || env.ALTALANDI_KEY;
+  // A Claude Desktop extension passes its optional key field through; when
+  // left empty it can arrive as "" or as the unexpanded "${user_config.api_key}".
+  const usable = (v) => (typeof v === "string" && v.trim() && !v.trim().startsWith("${") ? v.trim() : "");
+  const fromEnv = usable(env.ALTALANDI_API_KEY) || usable(env.ALTALANDI_KEY);
   if (fromEnv) return { key: fromEnv, source: "env" };
   try {
     const data = JSON.parse(readFileSync(path.join(configDir({ ...opts, env }), "credentials.json"), "utf8"));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "altalandi-mcp",
-  "version": "0.3.0",
+  "version": "0.6.0",
   "description": "MCP server exposing Altalandi (native-Icelandic refinement) as a tool for Claude Code and any MCP client.",
   "type": "module",
   "bin": {
@@ -9,6 +9,7 @@
   "files": [
     "server.mjs",
     "key.mjs",
+    "device.mjs",
     "api-client.mjs",
     "format-response.mjs",
     "report.mjs",

package/report.mjs

@@ -1,114 +1,280 @@
-// Before/after for people: a terminal view and an optional Markdown report.
-//
-// The website shows each change inline; in a terminal or an editor the
-// before/after got lost. This module renders it the same way everywhere:
-//   beforeAfterText()  plain (or coloured) block for a terminal or a tool result
-//   reportMarkdown()   the report file: input, output, every change with its
-//                      reason, and the verdict
-//   writeReport()      writes it to ./altalandi-reports/ (or ALTALANDI_REPORT_DIR)
-//
-// Reports are opt-in (--report, or ALTALANDI_REPORT=1): they contain the text.
-
-import { mkdir, writeFile } from "node:fs/promises";
-import { join, resolve } from "node:path";
-
-const VERDICT = {
-  rewritten: "Endurskrifað og merking staðfest",
-  refused: "Endurskrift hafnað: upprunalega textanum skilað óbreyttum",
-  unchanged: "Engin breyting þurfti",
-  unverified: "Merking ekki staðfest: farðu yfir áður en þú notar textann",
-};
-
-export function outcomeOf(data) {
-  if (data?.rejectionReason) return "refused";
-  if (data?.meaningPreserved === false) return "refused";
-  if (data?.rewriteAttempted === false) return "unchanged";
-  if (data?.meaningPreserved !== true) return "unverified";
-  return "rewritten";
-}
-
-export function reportEnabled(flag) {
-  if (flag !== undefined && flag !== null) return Boolean(flag);
-  return ["1", "true", "yes"].includes(String(process.env.ALTALANDI_REPORT || "").toLowerCase());
-}
-
-const paint = (on) => ({
-  red: (s) => (on ? `\x1b[31m${s}\x1b[0m` : s),
-  green: (s) => (on ? `\x1b[32m${s}\x1b[0m` : s),
-  dim: (s) => (on ? `\x1b[2m${s}\x1b[0m` : s),
-  bold: (s) => (on ? `\x1b[1m${s}\x1b[0m` : s),
-});
-
-/** A before/after block with the list of changes. `color` adds ANSI colours. */
-export function beforeAfterText(input, data, { color = false } = {}) {
-  const c = paint(color);
-  const diffs = Array.isArray(data?.diffs) ? data.diffs : [];
-  const rule = (label) => c.dim(`── ${label} ${"─".repeat(Math.max(4, 40 - label.length))}`);
-  const lines = [
-    rule("Fyrir"), String(input ?? ""), "",
-    rule("Eftir"), String(data?.output ?? ""), "",
-    rule(`Breytingar (${diffs.length})`),
-  ];
-  if (!diffs.length) lines.push(c.dim("Engar breytingar."));
-  diffs.forEach((d, i) => {
-    lines.push(`${i + 1}. ${c.red("− " + String(d.before ?? "").trim())}`);
-    lines.push(`   ${c.green("+ " + String(d.after ?? "").trim())}`);
-    if (d.reason) lines.push(`   ${c.dim("↳ " + String(d.reason))}`);
-  });
-  const q = data?.quality || {};
-  lines.push("", c.bold(VERDICT[outcomeOf(data)]) + (q.nativenessScore != null ? c.dim(` · innfæddni ${q.nativenessScore}/100`) : ""));
-  return lines.join("\n");
-}
-
-const fence = (s) => {
-  const text = String(s ?? "");
-  const ticks = text.includes("```") ? "````" : "```";
-  return `${ticks}text\n${text}\n${ticks}`;
-};
-const cell = (s) => String(s ?? "").replace(/\|/g, "\\|").replace(/\r?\n/g, " ").trim();
-
-export function reportMarkdown(input, data, options = {}) {
-  const q = data?.quality || {};
-  const diffs = Array.isArray(data?.diffs) ? data.diffs : [];
-  const warnings = Array.isArray(data?.warnings) ? data.warnings : [];
-  const tier = data?.billedTier || data?.tier || {};
-  const when = new Date().toISOString().replace("T", " ").slice(0, 19);
-  const out = [
-    `# Altalandi: ${data?.id || "yfirlestur"}`,
-    "",
-    `| | |`, `|---|---|`,
-    `| Tími | ${when} UTC |`,
-    `| Niðurstaða | ${VERDICT[outcomeOf(data)]} |`,
-    `| Frummál | ${data?.sourceLang || "?"} |`,
-    `| Tegund texta | ${options.domain || "general"} |`,
-    `| Málsnið | ${options.register || "neutral"} |`,
-    `| Innfæddni | ${q.nativenessScore ?? "n/a"}/100 |`,
-    `| Ritill | ${tier.writer || "standard"} / ${tier.scoring || "?"} |`,
-    `| Auðkenni | ${data?.id || "?"} |`,
-    "",
-    "## Fyrir", "", fence(input), "",
-    "## Eftir", "", fence(data?.output), "",
-    `## Breytingar (${diffs.length})`, "",
-  ];
-  if (diffs.length) {
-    out.push("| # | Fyrir | Eftir | Ástæða | Lag |", "|---|---|---|---|---|");
-    diffs.forEach((d, i) => out.push(`| ${i + 1} | ${cell(d.before)} | ${cell(d.after)} | ${cell(d.reason)} | ${cell(d.layer)} |`));
-  } else {
-    out.push("Engar breytingar.");
-  }
-  if (data?.rejectionReason) out.push("", "## Af hverju var endurskriftinni hafnað", "", cell(data.rejectionReason));
-  if (warnings.length) out.push("", "## Viðvaranir", "", ...warnings.map((w) => `- ${cell(w)}`));
-  if (data?.meaningNotes) out.push("", "## Athugun á merkingu", "", cell(data.meaningNotes));
-  return out.join("\n") + "\n";
-}
-
-/** Write the report; returns its path. */
-export async function writeReport(input, data, options = {}, dir) {
-  const base = resolve(dir || process.env.ALTALANDI_REPORT_DIR || join(process.cwd(), "altalandi-reports"));
-  await mkdir(base, { recursive: true });
-  const stamp = new Date().toISOString().replace(/[-:]/g, "").replace("T", "-").slice(0, 15);
-  const id = String(data?.id || "yfirlestur").replace(/[^A-Za-z0-9_-]/g, "");
-  const path = join(base, `altalandi-${stamp}-${id}.md`);
-  await writeFile(path, reportMarkdown(input, data, options), "utf8");
-  return path;
-}
+// Before/after for people: a terminal view and an optional Markdown report.
+//
+// The website shows each change inline; in a terminal or an editor the
+// before/after got lost. This module renders it the same way everywhere:
+//   beforeAfterText()  plain (or coloured) block for a terminal or a tool result
+//   reportMarkdown()   the report file: input, output, every change with its
+//                      reason, and the verdict
+//   writeReport()      writes it to ./altalandi-reports/ (or ALTALANDI_REPORT_DIR)
+//
+// Reports are opt-in (--report, or ALTALANDI_REPORT=1): they contain the text.
+
+import { mkdir, writeFile } from "node:fs/promises";
+import { join, resolve } from "node:path";
+
+const VERDICT = {
+  rewritten: "Endurskrifað og merking staðfest",
+  refused: "Endurskrift hafnað: upprunalega textanum skilað óbreyttum",
+  unchanged: "Engin breyting þurfti",
+  unverified: "Merking ekki staðfest: farðu yfir áður en þú notar textann",
+};
+
+export function outcomeOf(data) {
+  if (data?.rejectionReason) return "refused";
+  if (data?.meaningPreserved === false) return "refused";
+  if (data?.rewriteAttempted === false) return "unchanged";
+  if (data?.meaningPreserved !== true) return "unverified";
+  return "rewritten";
+}
+
+export function reportEnabled(flag) {
+  if (flag !== undefined && flag !== null) return Boolean(flag);
+  return ["1", "true", "yes"].includes(String(process.env.ALTALANDI_REPORT || "").toLowerCase());
+}
+
+const paint = (on) => ({
+  red: (s) => (on ? `\x1b[31m${s}\x1b[0m` : s),
+  green: (s) => (on ? `\x1b[32m${s}\x1b[0m` : s),
+  dim: (s) => (on ? `\x1b[2m${s}\x1b[0m` : s),
+  bold: (s) => (on ? `\x1b[1m${s}\x1b[0m` : s),
+});
+
+/** A before/after block with the list of changes. `color` adds ANSI colours. */
+export function beforeAfterText(input, data, { color = false } = {}) {
+  const c = paint(color);
+  const diffs = Array.isArray(data?.diffs) ? data.diffs : [];
+  const rule = (label) => c.dim(`── ${label} ${"─".repeat(Math.max(4, 40 - label.length))}`);
+  const lines = [
+    rule("Fyrir"), String(input ?? ""), "",
+    rule("Eftir"), String(data?.output ?? ""), "",
+    rule(`Breytingar (${diffs.length})`),
+  ];
+  if (!diffs.length) lines.push(c.dim("Engar breytingar."));
+  diffs.forEach((d, i) => {
+    lines.push(`${i + 1}. ${c.red("− " + String(d.before ?? "").trim())}`);
+    lines.push(`   ${c.green("+ " + String(d.after ?? "").trim())}`);
+    if (d.reason) lines.push(`   ${c.dim("↳ " + String(d.reason))}`);
+  });
+  const q = data?.quality || {};
+  lines.push("", c.bold(VERDICT[outcomeOf(data)]) + (q.nativenessScore != null ? c.dim(` · innfæddni ${q.nativenessScore}/100`) : ""));
+  return lines.join("\n");
+}
+
+const fence = (s) => {
+  const text = String(s ?? "");
+  const ticks = text.includes("```") ? "````" : "```";
+  return `${ticks}text\n${text}\n${ticks}`;
+};
+const cell = (s) => String(s ?? "").replace(/\|/g, "\\|").replace(/\r?\n/g, " ").trim();
+
+export function reportMarkdown(input, data, options = {}) {
+  const q = data?.quality || {};
+  const diffs = Array.isArray(data?.diffs) ? data.diffs : [];
+  const warnings = Array.isArray(data?.warnings) ? data.warnings : [];
+  const tier = data?.billedTier || data?.tier || {};
+  const when = new Date().toISOString().replace("T", " ").slice(0, 19);
+  const out = [
+    `# Altalandi: ${data?.id || "yfirlestur"}`,
+    "",
+    `| | |`, `|---|---|`,
+    `| Tími | ${when} UTC |`,
+    `| Niðurstaða | ${VERDICT[outcomeOf(data)]} |`,
+    `| Frummál | ${data?.sourceLang || "?"} |`,
+    `| Tegund texta | ${options.domain || "general"} |`,
+    `| Málsnið | ${options.register || "neutral"} |`,
+    `| Innfæddni | ${q.nativenessScore ?? "n/a"}/100 |`,
+    `| Ritill | ${tier.writer || "standard"} / ${tier.scoring || "?"} |`,
+    `| Auðkenni | ${data?.id || "?"} |`,
+    "",
+    "## Fyrir", "", fence(input), "",
+    "## Eftir", "", fence(data?.output), "",
+    `## Breytingar (${diffs.length})`, "",
+  ];
+  if (diffs.length) {
+    out.push("| # | Fyrir | Eftir | Ástæða | Lag |", "|---|---|---|---|---|");
+    diffs.forEach((d, i) => out.push(`| ${i + 1} | ${cell(d.before)} | ${cell(d.after)} | ${cell(d.reason)} | ${cell(d.layer)} |`));
+  } else {
+    out.push("Engar breytingar.");
+  }
+  if (data?.rejectionReason) out.push("", "## Af hverju var endurskriftinni hafnað", "", cell(data.rejectionReason));
+  if (warnings.length) out.push("", "## Viðvaranir", "", ...warnings.map((w) => `- ${cell(w)}`));
+  if (data?.meaningNotes) out.push("", "## Athugun á merkingu", "", cell(data.meaningNotes));
+  return out.join("\n") + "\n";
+}
+
+/** Write the report; returns its path. */
+export async function writeReport(input, data, options = {}, dir) {
+  const base = resolve(dir || process.env.ALTALANDI_REPORT_DIR || join(process.cwd(), "altalandi-reports"));
+  await mkdir(base, { recursive: true });
+  const stamp = new Date().toISOString().replace(/[-:]/g, "").replace("T", "-").slice(0, 15);
+  const id = String(data?.id || "yfirlestur").replace(/[^A-Za-z0-9_-]/g, "");
+  const path = join(base, `altalandi-${stamp}-${id}.md`);
+  await writeFile(path, reportMarkdown(input, data, options), "utf8");
+  return path;
+}
+
+// ── The review block ─────────────────────────────────────────────────────────
+// One Markdown block an agent pastes into the chat as it is: verdict, the text
+// before and after, every change with its reason, what the call cost and what
+// is left. `--review` prints it; the MCP tool returns it. The agent does not
+// rebuild it from JSON, so every run looks the same.
+
+const REJECTION = [
+  ["MEANING DRIFT", "merkingin breyttist í endurskriftinni"],
+  ["HARD INVARIANT LOST", "tala, dagsetning, nafn eða neitun hefði glatast"],
+  ["UNVERIFIED", "ekki tókst að staðfesta að merkingin héldist"],
+  ["CANDIDATE VETO", "endurskriftin reyndist ekki betri en frumtextinn"],
+];
+
+export function rejectionText(reason) {
+  const raw = String(reason ?? "").trim();
+  if (!raw) return "";
+  const hit = REJECTION.find(([code]) => raw.toUpperCase().startsWith(code));
+  return hit ? `${hit[1][0].toUpperCase()}${hit[1].slice(1)} (${raw})` : raw;
+}
+
+/** 1688 → "1.688" (Icelandic thousands separator). */
+export function formatInt(n) {
+  return String(Math.round(Number(n))).replace(/\B(?=(\d{3})+(?!\d))/g, ".");
+}
+
+/** 487.5 → "487,50 kr.", 500 → "500 kr." */
+export function formatIsk(n) {
+  const v = Math.round(Number(n) * 100) / 100;
+  const sign = v < 0 ? "−" : "";
+  const abs = Math.abs(v);
+  const whole = formatInt(Math.trunc(abs));
+  const cents = Math.round((abs - Math.trunc(abs)) * 100);
+  return `${sign}${whole}${cents ? "," + String(cents).padStart(2, "0") : ""} kr.`;
+}
+
+const num = (v) => (typeof v === "number" && Number.isFinite(v) ? v : null);
+
+/**
+ * What the call cost and what is left. `data.billing` (sent by newer engines)
+ * is exact; otherwise the cost is the balance difference between /v1/me
+ * before and after the call, which parallel calls on the same account blur.
+ */
+export function costLines(data, before, after) {
+  if (data?.test) return ["- Prófunarlykill: ekkert var rukkað og ekkert líkan keyrði."];
+  const b = data?.billing || {};
+  let charged = num(b.chargedIsk);
+  const exact = charged != null;
+  if (charged == null && num(before?.balanceIsk) != null && num(after?.balanceIsk) != null) {
+    charged = Math.round((before.balanceIsk - after.balanceIsk) * 100) / 100;
+  }
+  const units = num(b.units);
+  const unitsText = units != null ? ` · ${formatInt(units)} einingar` : "";
+  const lines = [];
+  if (charged == null) lines.push(`- Þetta kall: kostnaður óþekktur${unitsText}`);
+  else if (charged < 0) lines.push(`- Þetta kall: ekki hægt að reikna (inneignin breyttist á meðan)${unitsText}`);
+  else if (charged === 0) lines.push(b.paidFrom === "credit"
+    ? `- Þetta kall: 0 kr. af inneign${unitsText}`
+    : `- Þetta kall: 0 kr., ókeypis dagskammtur${unitsText}`);
+  else lines.push(`- Þetta kall: ${formatIsk(charged)} af inneign${exact ? "" : " (mismunur á inneign fyrir og eftir)"}${unitsText}`);
+
+  const balance = num(b.balanceIsk) ?? num(after?.balanceIsk);
+  const left = num(b.freeUnitsLeftToday) ?? num(after?.freeUnitsLeftToday);
+  const daily = num(after?.freeDailyUnits) ?? num(before?.freeDailyUnits);
+  const parts = [];
+  if (balance != null) parts.push(`inneign ${formatIsk(balance)}`);
+  if (left != null && daily != null) parts.push(`ókeypis eftir í dag ${formatInt(left)} af ${formatInt(daily)} einingum`);
+  else if (left != null) parts.push(`ókeypis eftir í dag ${formatInt(left)} einingar`);
+  else if (daily != null && daily > 0) parts.push(`ókeypis ${formatInt(daily)} einingar á dag`);
+  if (parts.length) lines.push(`- Staða: ${parts.join(" · ")}`);
+  else lines.push("- Staða: náðist ekki að sækja (`npx altalandi whoami`)");
+  if (balance != null && balance < 50) lines.push("- Bæta við inneign: https://altalandi.is/portal");
+  return lines;
+}
+
+function clip(text, max) {
+  const s = String(text ?? "");
+  if (!max || s.length <= max) return { text: s, clipped: false };
+  const cut = s.lastIndexOf(" ", max);
+  return { text: s.slice(0, cut > max * 0.6 ? cut : max).trimEnd() + " …", clipped: true };
+}
+
+// A quoted line that starts with "#" or ">" would render as a heading or a
+// nested quote; escape that first character.
+const quote = (s) => String(s).split(/\r?\n/)
+  .map((l) => (l.trim() ? `> ${l.replace(/^(\s*)([#>])/, "$1\\$2")}` : ">")).join("\n");
+const inline = (s) => String(s ?? "").replace(/\s+/g, " ").trim().replace(/([\\`*_~[\]<>|#])/g, "\\$1");
+
+/**
+ * The block to show the user. `before`/`after` are /v1/me responses (either
+ * may be null). Long texts are shortened for the chat; `fullTextAt` names the
+ * file that holds the whole output.
+ */
+export function reviewMarkdown(input, data, { before = null, after = null, maxChars = 1500, maxChanges = 30, fullTextAt = "" } = {}) {
+  const q = data?.quality || {};
+  const outcome = outcomeOf(data);
+  const diffs = Array.isArray(data?.diffs) ? data.diffs : [];
+  const score = q.nativenessScore != null ? ` · innfæddni ${q.nativenessScore}/100` : "";
+  const out = [`**Altalandi:** ${VERDICT[outcome]}${score}`, ""];
+
+  const inText = clip(input, maxChars);
+  out.push("**Fyrir**", quote(inText.text), "");
+  const same = String(data?.output ?? "").trim() === String(input ?? "").trim();
+  if (same) {
+    out.push("**Eftir**", outcome === "refused" ? "> Óbreytt: upprunalega textanum var skilað." : "> Óbreytt.", "");
+  } else {
+    const outText = clip(data?.output, maxChars);
+    out.push("**Eftir**", quote(outText.text), "");
+    if (outText.clipped || inText.clipped) {
+      out.push(`_Textinn er styttur hér${fullTextAt ? `; allur textinn er í ${fullTextAt}` : ""}._`, "");
+    }
+  }
+
+  if (outcome === "refused" && data?.rejectionReason) {
+    out.push(`**Af hverju óbreytt:** ${inline(rejectionText(data.rejectionReason))}`, "");
+  }
+
+  if (diffs.length) {
+    out.push(`**Breytingar (${diffs.length})**`);
+    diffs.slice(0, maxChanges).forEach((d, i) => {
+      out.push(`${i + 1}. „${inline(d.before)}“ → „${inline(d.after)}“`);
+      if (d.reason) out.push(`   Ástæða: ${inline(d.reason)}`);
+    });
+    if (diffs.length > maxChanges) out.push(`   … og ${diffs.length - maxChanges} í viðbót (sjá \`--report\`).`);
+    out.push("");
+  } else if (data?.diffStatus === "translation" || (data?.sourceLang === "en" && !same)) {
+    out.push("**Breytingar:** þýðing úr ensku, svo allur textinn er nýr.", "");
+  } else if (!same && data?.diffStatus === "unavailable") {
+    out.push("**Breytingar:** textinn breyttist en listi yfir breytingar fékkst ekki. Berðu saman fyrir og eftir.", "");
+  } else if (outcome !== "refused") {
+    out.push("**Breytingar:** engar.", "");
+  }
+
+  // The refusal reason is already shown above; its warning repeats it.
+  const code = REJECTION.find(([c]) => String(data?.rejectionReason ?? "").toUpperCase().startsWith(c))?.[0];
+  const warnings = (Array.isArray(data?.warnings) ? data.warnings : [])
+    .filter((w) => !String(w).startsWith("TEST KEY") && !(code && String(w).toUpperCase().startsWith(code)));
+  if (warnings.length && outcome !== "rewritten") {
+    out.push("**Athugasemdir**", ...warnings.slice(0, 3).map((w) => `- ${inline(w)}`), "");
+  }
+
+  const term = data?.terminology;
+  if (term?.dictionaries?.length) {
+    // Offered is not used: only a term verified in the output (by form or BÍN
+    // lemma) is "í textanum"; a stem-only match is "líklega"; an older engine
+    // without `usage` is listed as offered. The caller's glossary wins.
+    const usage = (x) => x.status === "overridden" ? "overridden"
+      : x.usage ?? (x.inOutput === true ? "verified" : x.inOutput === false ? "absent" : "unchecked");
+    const tag = { verified: "í textanum", probable: "líklega í textanum", absent: "ekki notað",
+                  unchecked: "boðið", overridden: "þitt orðasafn gekk framar" };
+    const shown = (term.terms || []).filter((x) => !x.inText);
+    out.push(`**Íðorð:** ${inline(term.dictionaries.map((d) => d.name).join(", "))} (úr Íðorðabanka Árnastofnunar)`);
+    if (!shown.some((x) => x.status !== "overridden")) out.push("- Ekkert íðorð var boðið fyrir þennan texta.");
+    shown.slice(0, 12).forEach((x) => {
+      const u = usage(x);
+      const is = u === "verified" || u === "probable" ? (x.used ?? x.is) : x.is;
+      out.push(`- ${inline(x.source)} → ${inline(is)} (${tag[u]})`);
+    });
+    if (shown.length > 12) out.push(`- … og ${shown.length - 12} í viðbót`);
+    out.push("");
+  }
+
+  out.push("**Kostnaður**", ...costLines(data, before, after));
+  if (data?.id) out.push(`- Auðkenni: \`${data.id}\``);
+  return out.join("\n") + "\n";
+}

package/server.mjs

@@ -11,17 +11,37 @@
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
 import { z } from "zod";
-import { requestRefine } from "./api-client.mjs";
-import { formatRefineResponse, outcomeOf } from "./format-response.mjs";
+import { requestMe, requestRefine, requestSuggestionDecisions } from "./api-client.mjs";
+import { beginLogin } from "./device.mjs";
+import { formatProofreadResponse, outcomeOf } from "./format-response.mjs";
 import { resolveKey } from "./key.mjs";
-import { beforeAfterText, reportEnabled, writeReport } from "./report.mjs";
+import { reportEnabled, reviewMarkdown, writeReport } from "./report.mjs";
 
 const BASE = (process.env.ALTALANDI_BASE_URL || "https://altalandi.is/api").replace(/\/$/, "");
-const server = new McpServer({ name: "altalandi", version: "0.3.0" });
+const server = new McpServer({ name: "altalandi", version: "0.6.0" });
+
+// No key yet: offer the sign-in instead of an error. The approval is picked up
+// in the background, so the next call simply works (Claude Desktop, where
+// nobody runs `npx altalandi login`).
+async function connectFirst() {
+  const r = await beginLogin(BASE, { client: process.env.ALTALANDI_CLIENT_NAME || "Claude Desktop" });
+  if (r.error) {
+    return { content: [{ type: "text", text: `Altalandi is not connected and the sign-in could not start: ${r.error}` }], isError: true };
+  }
+  return {
+    content: [{ type: "text", text:
+      "**Tengdu Altalandi fyrst** (connect Altalandi first).\n\n" +
+      `1. Opnaðu ${r.link}\n` +
+      "2. Skráðu þig inn eða stofnaðu aðgang (2.000 einingar ókeypis á dag, 500 kr. prufuinneign).\n" +
+      `3. Staðfestu kóðann **${r.code}** og smelltu á **Tengja**.\n\n` +
+      "Show the person this link and code, wait until they say it is done, then call the tool again with the same text." }],
+    isError: true,
+  };
+}
 
 server.tool(
   "refine_icelandic",
-  "Rewrite English or stiff/AI-translated Icelandic into native-sounding Icelandic, with a meaning-preservation check. Use whenever you need Icelandic that must read like a native wrote it (marketing copy, UI strings, prose). Returns the refined text, a 0-100 nativeness score, an explicit meaning verdict, and every API warning. Only 'meaning preserved' is verified; 'MEANING UNVERIFIED' requires review. On drift it returns the original unchanged. After every call, show the user the before/after block from the result (Fyrir / Eftir) and the numbered list of changes with their reasons, then mention the report path if one was written. Never replace the user's text silently.",
+  "Rewrite English or stiff/AI-translated Icelandic into native-sounding Icelandic, with a meaning-preservation check. Use whenever you need Icelandic that must read like a native wrote it (marketing copy, UI strings, prose). Returns the refined text, a 0-100 nativeness score, an explicit meaning verdict, and every API warning. Only 'meaning preserved' is verified; 'MEANING UNVERIFIED' requires review. On drift it returns the original unchanged. After every call, show the user the first part of the result (the Altalandi block: verdict, Fyrir, Eftir, every change with its reason, Kostnaður) exactly as it is, before anything else; do not rewrite or summarise it. The second part is the full refined text to apply. Never replace the user's text silently, and never present your own edits as Altalandi's.",
   {
     text: z.string().describe("Text to refine (English or Icelandic)."),
     domain: z.enum(["general", "marketing", "data-analysis", "childrens-fiction"]).optional()
@@ -31,21 +51,21 @@ server.tool(
       .describe("Source-language hint. Default auto."),
     report: z.boolean().optional()
       .describe("Also write a Markdown report (input, output, every change with its reason, verdict) to ./altalandi-reports/. Default: on when ALTALANDI_REPORT=1."),
+    noStore: z.boolean().optional()
+      .describe("true = Altalandi never keeps this text. Otherwise free use is kept, scrubbed of personal data, to improve the service. Set it when the user asks that their text not be kept, or the text is confidential."),
   },
-  async ({ text, domain, register, sourceLang, report }) => {
+  async ({ text, domain, register, sourceLang, report, noStore }) => {
     // Resolved per call, so a login made after the server started is picked up.
     const { key: KEY } = resolveKey();
-    if (!KEY) {
-      return { content: [{ type: "text", text:
-        "No Altalandi key found. Run `npx altalandi login` once on this computer, or set ALTALANDI_API_KEY." }],
-        isError: true };
-    }
+    if (!KEY) return connectFirst();
+    const before = await requestMe(BASE, KEY);
     try {
       const { response, data } = await requestRefine(BASE, KEY, {
         text,
         domain,
         register,
         sourceLang,
+        ...(noStore ? { contribute: false } : {}),
       });
       if (!response.ok) {
         return { content: [{ type: "text", text: `Altalandi error ${response.status}: ${data.detail || response.statusText}` }], isError: true };
@@ -59,7 +79,10 @@ server.tool(
         }
       }
       return {
-        content: [{ type: "text", text: `${formatRefineResponse(data)}\n\n${beforeAfterText(text, data)}${reportLine}` }],
+        content: [
+          { type: "text", text: reviewMarkdown(text, data, { before, after: await requestMe(BASE, KEY) }) + reportLine },
+          { type: "text", text: `Full refined text (apply only after showing the block above):\n\n${String(data.output ?? "")}` },
+        ],
         // MCP callers should not treat a refused rewrite (drift, a lost
         // invariant, or a candidate veto) or an unverified response as a
         // successfully refined artifact. "No rewrite needed" is a success. The
@@ -72,4 +95,71 @@ server.tool(
   },
 );
 
+server.tool(
+  "proofread_icelandic",
+  "Proofread Icelandic text the person wrote, keeping their wording. Proven errors (punctuation, word boundaries, a misspelt word one slip from the right one) are fixed in the returned text. Other corrections come back as numbered suggestions with a reason and, when known, how sure each is ('both checks agree', 'one check', 'rule (BÍN)'). Show the corrected text and every suggestion, ask which to apply, apply only those the person accepts, then call record_suggestion_decisions with the resultId and a decision for every suggestion. suggestions='apply' applies the kinds measured right at least minPrecision of the time and offers the rest; 'off' returns only the safe fixes.",
+  {
+    text: z.string().describe("The Icelandic text to proofread."),
+    suggestions: z.enum(["offer", "apply", "off"]).optional()
+      .describe("What happens to suggestions. Default offer (the person chooses)."),
+    minPrecision: z.number().min(0.5).max(0.99).optional()
+      .describe("With suggestions='apply': the lowest measured precision a kind of suggestion needs to be applied. Default 0.9."),
+    noStore: z.boolean().optional()
+      .describe("true = Altalandi never keeps this text (nor the words of its suggestions)."),
+  },
+  async ({ text, suggestions, minPrecision, noStore }) => {
+    const { key: KEY } = resolveKey();
+    if (!KEY) return connectFirst();
+    try {
+      const { response, data } = await requestRefine(BASE, KEY, {
+        text, task: "proofread", sourceLang: "is",
+        ...(suggestions ? { suggestions } : {}), ...(minPrecision ? { minPrecision } : {}),
+        ...(noStore ? { contribute: false } : {}),
+      });
+      if (!response.ok) {
+        return { content: [{ type: "text", text: `Altalandi error ${response.status}: ${data.detail || response.statusText}` }], isError: true };
+      }
+      return { content: [{ type: "text", text: formatProofreadResponse(data) }] };
+    } catch (e) {
+      return { content: [{ type: "text", text: `Request failed: ${e.message}` }], isError: true };
+    }
+  },
+);
+
+server.tool(
+  "record_suggestion_decisions",
+  "After proofread_icelandic: record, for every numbered suggestion, whether the person used it or ignored it. Free; no model runs; no text is sent. Call it once the person has decided.",
+  {
+    resultId: z.string().regex(/^r_[0-9a-f]{8,32}$/).describe("The resultId proofread_icelandic returned."),
+    decisions: z.array(z.object({ index: z.number().int().min(0).max(499), decision: z.enum(["used", "ignored"]) }))
+      .min(1).max(100).describe("Each suggestion's number and what the person chose."),
+  },
+  async ({ resultId, decisions }) => {
+    const { key: KEY } = resolveKey();
+    if (!KEY) return connectFirst();
+    const r = await requestSuggestionDecisions(BASE, KEY, { resultId, decisions, client: "claude" });
+    if (!r.ok) return { content: [{ type: "text", text: `Could not record the decisions: ${r.error}` }], isError: true };
+    return { content: [{ type: "text", text: `Recorded ${r.recorded} decision(s)${r.refused ? `, ${r.refused} refused` : ""}. Thank you.` }] };
+  },
+);
+
+server.tool(
+  "altalandi_status",
+  "The connected Altalandi account: balance, today's free units left, and where to add credit. Use when the person asks about their balance or credit, or before a large batch.",
+  {},
+  async () => {
+    const { key: KEY } = resolveKey();
+    if (!KEY) return connectFirst();
+    const me = await requestMe(BASE, KEY);
+    if (!me) return { content: [{ type: "text", text: "Could not reach Altalandi to read the account." }], isError: true };
+    const isk = (n) => (typeof n === "number" ? `${n.toFixed(2).replace(".", ",").replace(/,00$/, "")} kr.` : "—");
+    const free = me.freeUnitsLeftToday != null && me.freeDailyUnits != null
+      ? `${me.freeUnitsLeftToday} of ${me.freeDailyUnits} free units left today`
+      : me.freeDailyUnits ? `${me.freeDailyUnits} free units a day` : "no free daily units";
+    return { content: [{ type: "text", text:
+      `**Altalandi:** ${me.username ?? "connected"} · inneign ${isk(me.balanceIsk)} · ${free}.\n` +
+      "Add credit: https://altalandi.is/dashboard/billing" }] };
+  },
+);
+
 await server.connect(new StdioServerTransport());