altalandi 0.6.1 → 0.6.3

package/client.mjs

@@ -1,219 +1,260 @@
-const DEFAULT_BASE_URL = "https://altalandi.is/api";
-const DEFAULT_TIMEOUT_MS = 300_000;
-const REQUEST_FIELDS = [
-  "sourceLang",
-  "domain",
-  "register",
-  "preserveMeaning",
-  "scoreNativeness",
-  "onlyImprove",
-  "polishPass",
-  "writer",
-  "scoring",
-  "glossary",
-  "returnDiffs",
-  "contribute",
-];
-
-export class AltalandiError extends Error {
-  constructor(message, { code = "ALTALANDI_ERROR", status, retryAfterMs } = {}) {
-    super(message);
-    this.name = "AltalandiError";
-    this.code = code;
-    if (Number.isInteger(status)) this.status = status;
-    if (Number.isFinite(retryAfterMs)) this.retryAfterMs = retryAfterMs;
-  }
-}
-
-/** Retry-After as milliseconds: delay-seconds or an HTTP date. */
-function retryAfterMs(response) {
-  const value = response?.headers?.get?.("retry-after");
-  if (!value) return undefined;
-  if (/^\s*\d+\s*$/.test(value)) return Number(value) * 1000;
-  const at = Date.parse(value);
-  return Number.isFinite(at) ? Math.max(0, at - Date.now()) : undefined;
-}
-
-export class MeaningVerificationError extends AltalandiError {
-  constructor(verdict) {
-    const changed = verdict === false;
-    super(
-      changed
-        ? "Altalandi could not preserve the input meaning."
-        : "Altalandi did not return a verified meaning verdict.",
-      { code: changed ? "MEANING_NOT_PRESERVED" : "MEANING_UNVERIFIED" },
-    );
-    this.name = "MeaningVerificationError";
-    this.verdict = verdict === false ? false : null;
-  }
-}
-
-function env(name) {
-  if (typeof process === "undefined" || !process.env) return undefined;
-  return process.env[name];
-}
-
-function cleanText(value, secret = "") {
-  if (typeof value !== "string") return "";
-  let cleaned = value.replace(/[\u0000-\u001f\u007f]+/g, " ").replace(/\s+/g, " ").trim();
-  if (secret) cleaned = cleaned.split(secret).join("[redacted]");
-  return cleaned.slice(0, 300);
-}
-
-function errorDetail(payload) {
-  const detail = payload?.detail;
-  if (typeof detail === "string") return detail;
-  if (Array.isArray(detail)) {
-    return detail
-      .map((entry) => (typeof entry?.msg === "string" ? entry.msg : ""))
-      .filter(Boolean)
-      .join("; ");
-  }
-  return "";
-}
-
-function requestBody(text, options) {
-  const body = { text };
-  for (const field of REQUEST_FIELDS) {
-    if (options[field] !== undefined) body[field] = options[field];
-  }
-  return body;
-}
-
-/**
- * Refine English or Icelandic text through the hosted Altalandi API.
- * Client settings (`apiKey`, `baseUrl`, `timeoutMs`, `fetch`) are never sent in
- * the JSON body. The full API result is returned without weakening its verdict.
- */
-export async function refine(text, options = {}) {
-  if (typeof text !== "string" || !text.trim()) {
-    throw new AltalandiError("Altalandi requires non-empty text.", { code: "INVALID_INPUT" });
-  }
-
-  const explicitKey = options.apiKey;
-  const selectedKey = explicitKey === undefined ? env("ALTALANDI_API_KEY") : explicitKey;
-  if (selectedKey !== undefined && typeof selectedKey !== "string") {
-    throw new AltalandiError("Altalandi apiKey must be a string.", { code: "INVALID_CONFIG" });
-  }
-  const apiKey = selectedKey?.trim();
-  if (!apiKey) {
-    throw new AltalandiError(
-      "No Altalandi API key. Set ALTALANDI_API_KEY or pass apiKey explicitly.",
-      { code: "MISSING_API_KEY" },
-    );
-  }
-
-  const selectedBaseUrl = options.baseUrl ?? DEFAULT_BASE_URL;
-  if (typeof selectedBaseUrl !== "string") {
-    throw new AltalandiError("Altalandi baseUrl must be a string.", { code: "INVALID_CONFIG" });
-  }
-  const baseUrl = selectedBaseUrl.trim().replace(/\/+$/, "");
-  if (!baseUrl) {
-    throw new AltalandiError("Altalandi baseUrl must not be empty.", { code: "INVALID_CONFIG" });
-  }
-
-  const timeoutMs = options.timeoutMs ?? DEFAULT_TIMEOUT_MS;
-  if (!Number.isFinite(timeoutMs) || timeoutMs <= 0) {
-    throw new AltalandiError("Altalandi timeoutMs must be a positive number.", {
-      code: "INVALID_CONFIG",
-    });
-  }
-
-  const fetchImpl = options.fetch ?? globalThis.fetch;
-  if (typeof fetchImpl !== "function") {
-    throw new AltalandiError("This runtime does not provide fetch.", { code: "INVALID_CONFIG" });
-  }
-
-  const controller = new AbortController();
-  const timeout = setTimeout(() => controller.abort(), timeoutMs);
-  try {
-    let response;
-    try {
-      response = await fetchImpl(`${baseUrl}/v1/refine`, {
-        method: "POST",
-        headers: {
-          "content-type": "application/json",
-          authorization: `Bearer ${apiKey}`,
-        },
-        body: JSON.stringify(requestBody(text, options)),
-        signal: controller.signal,
-      });
-    } catch {
-      if (controller.signal.aborted) {
-        throw new AltalandiError(`Altalandi timed out after ${timeoutMs} ms.`, {
-          code: "TIMEOUT",
-        });
-      }
-      throw new AltalandiError("Altalandi could not reach the API.", { code: "NETWORK_ERROR" });
-    }
-
-    let raw = "";
-    try {
-      raw = await response.text();
-    } catch {
-      if (controller.signal.aborted) {
-        throw new AltalandiError(`Altalandi timed out after ${timeoutMs} ms.`, {
-          code: "TIMEOUT",
-        });
-      }
-      if (response.ok) {
-        throw new AltalandiError("Altalandi could not read the API response.", {
-          code: "INVALID_RESPONSE",
-          status: response.status,
-        });
-      }
-      // The HTTP status remains useful when an error response has no readable body.
-    }
-
-    let payload;
-    if (raw) {
-      try {
-        payload = JSON.parse(raw);
-      } catch {
-        if (response.ok) {
-          throw new AltalandiError("Altalandi returned an invalid JSON response.", {
-            code: "INVALID_RESPONSE",
-            status: response.status,
-          });
-        }
-      }
-    }
-
-    if (!response.ok) {
-      const status = Number.isInteger(response.status) ? response.status : 0;
-      const statusText = cleanText(response.statusText);
-      const detail = cleanText(errorDetail(payload), apiKey);
-      const suffix = detail || statusText;
-      throw new AltalandiError(
-        `Altalandi API request failed (${status || "unknown status"})${suffix ? `: ${suffix}` : "."}`,
-        { code: "API_ERROR", status, retryAfterMs: retryAfterMs(response) },
-      );
-    }
-
-    if (!payload || typeof payload !== "object" || Array.isArray(payload) || typeof payload.output !== "string") {
-      throw new AltalandiError("Altalandi returned an invalid response shape.", {
-        code: "INVALID_RESPONSE",
-        status: response.status,
-      });
-    }
-
-    return payload;
-  } finally {
-    clearTimeout(timeout);
-  }
-}
-
-/** Assert that an existing result carries a completed, positive meaning check. */
-export function assertMeaningVerified(result) {
-  if (result?.meaningPreserved !== true) {
-    throw new MeaningVerificationError(result?.meaningPreserved);
-  }
-  return result;
-}
-
-/** Request meaning verification and reject unless the API returns strict true. */
-export async function refineVerified(text, options = {}) {
-  const result = await refine(text, { ...options, preserveMeaning: true });
-  assertMeaningVerified(result);
-  return result;
-}
+const DEFAULT_BASE_URL = "https://altalandi.is/api";
+const DEFAULT_TIMEOUT_MS = 300_000;
+const REQUEST_FIELDS = [
+  "sourceLang",
+  "domain",
+  "register",
+  "preserveMeaning",
+  "scoreNativeness",
+  "onlyImprove",
+  "polishPass",
+  "writer",
+  "scoring",
+  "glossary",
+  "returnDiffs",
+  "contribute",
+  "job",
+];
+// /v1/refine/batch takes fewer options: no writer/scoring tiers, polish or diffs switch.
+const BATCH_REQUEST_FIELDS = [
+  "sourceLang",
+  "domain",
+  "register",
+  "preserveMeaning",
+  "scoreNativeness",
+  "onlyImprove",
+  "glossary",
+  "autoTerminology",
+  "contribute",
+  "job",
+];
+
+export class AltalandiError extends Error {
+  constructor(message, { code = "ALTALANDI_ERROR", status, retryAfterMs } = {}) {
+    super(message);
+    this.name = "AltalandiError";
+    this.code = code;
+    if (Number.isInteger(status)) this.status = status;
+    if (Number.isFinite(retryAfterMs)) this.retryAfterMs = retryAfterMs;
+  }
+}
+
+/** Retry-After as milliseconds: delay-seconds or an HTTP date. */
+function retryAfterMs(response) {
+  const value = response?.headers?.get?.("retry-after");
+  if (!value) return undefined;
+  if (/^\s*\d+\s*$/.test(value)) return Number(value) * 1000;
+  const at = Date.parse(value);
+  return Number.isFinite(at) ? Math.max(0, at - Date.now()) : undefined;
+}
+
+export class MeaningVerificationError extends AltalandiError {
+  constructor(verdict) {
+    const changed = verdict === false;
+    super(
+      changed
+        ? "Altalandi could not preserve the input meaning."
+        : "Altalandi did not return a verified meaning verdict.",
+      { code: changed ? "MEANING_NOT_PRESERVED" : "MEANING_UNVERIFIED" },
+    );
+    this.name = "MeaningVerificationError";
+    this.verdict = verdict === false ? false : null;
+  }
+}
+
+function env(name) {
+  if (typeof process === "undefined" || !process.env) return undefined;
+  return process.env[name];
+}
+
+function cleanText(value, secret = "") {
+  if (typeof value !== "string") return "";
+  let cleaned = value.replace(/[\u0000-\u001f\u007f]+/g, " ").replace(/\s+/g, " ").trim();
+  if (secret) cleaned = cleaned.split(secret).join("[redacted]");
+  return cleaned.slice(0, 300);
+}
+
+function errorDetail(payload) {
+  const detail = payload?.detail;
+  if (typeof detail === "string") return detail;
+  if (Array.isArray(detail)) {
+    return detail
+      .map((entry) => (typeof entry?.msg === "string" ? entry.msg : ""))
+      .filter(Boolean)
+      .join("; ");
+  }
+  return "";
+}
+
+function requestBody(text, options) {
+  const body = { text };
+  for (const field of REQUEST_FIELDS) {
+    if (options[field] !== undefined) body[field] = options[field];
+  }
+  return body;
+}
+
+/** POST a JSON body to `${baseUrl}${route}` with the key, base URL, timeout and
+ *  error handling every call shares. Returns the payload when `validShape`
+ *  accepts it; throws an AltalandiError (with status and Retry-After) otherwise. */
+async function post(route, body, options, validShape) {
+  const explicitKey = options.apiKey;
+  const selectedKey = explicitKey === undefined ? env("ALTALANDI_API_KEY") : explicitKey;
+  if (selectedKey !== undefined && typeof selectedKey !== "string") {
+    throw new AltalandiError("Altalandi apiKey must be a string.", { code: "INVALID_CONFIG" });
+  }
+  const apiKey = selectedKey?.trim();
+  if (!apiKey) {
+    throw new AltalandiError(
+      "No Altalandi API key. Set ALTALANDI_API_KEY or pass apiKey explicitly.",
+      { code: "MISSING_API_KEY" },
+    );
+  }
+
+  const selectedBaseUrl = options.baseUrl ?? DEFAULT_BASE_URL;
+  if (typeof selectedBaseUrl !== "string") {
+    throw new AltalandiError("Altalandi baseUrl must be a string.", { code: "INVALID_CONFIG" });
+  }
+  const baseUrl = selectedBaseUrl.trim().replace(/\/+$/, "");
+  if (!baseUrl) {
+    throw new AltalandiError("Altalandi baseUrl must not be empty.", { code: "INVALID_CONFIG" });
+  }
+
+  const timeoutMs = options.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+  if (!Number.isFinite(timeoutMs) || timeoutMs <= 0) {
+    throw new AltalandiError("Altalandi timeoutMs must be a positive number.", {
+      code: "INVALID_CONFIG",
+    });
+  }
+
+  const fetchImpl = options.fetch ?? globalThis.fetch;
+  if (typeof fetchImpl !== "function") {
+    throw new AltalandiError("This runtime does not provide fetch.", { code: "INVALID_CONFIG" });
+  }
+
+  const controller = new AbortController();
+  const timeout = setTimeout(() => controller.abort(), timeoutMs);
+  try {
+    let response;
+    try {
+      response = await fetchImpl(`${baseUrl}${route}`, {
+        method: "POST",
+        headers: {
+          "content-type": "application/json",
+          authorization: `Bearer ${apiKey}`,
+        },
+        body: JSON.stringify(body),
+        signal: controller.signal,
+      });
+    } catch {
+      if (controller.signal.aborted) {
+        throw new AltalandiError(`Altalandi timed out after ${timeoutMs} ms.`, {
+          code: "TIMEOUT",
+        });
+      }
+      throw new AltalandiError("Altalandi could not reach the API.", { code: "NETWORK_ERROR" });
+    }
+
+    let raw = "";
+    try {
+      raw = await response.text();
+    } catch {
+      if (controller.signal.aborted) {
+        throw new AltalandiError(`Altalandi timed out after ${timeoutMs} ms.`, {
+          code: "TIMEOUT",
+        });
+      }
+      if (response.ok) {
+        throw new AltalandiError("Altalandi could not read the API response.", {
+          code: "INVALID_RESPONSE",
+          status: response.status,
+        });
+      }
+      // The HTTP status remains useful when an error response has no readable body.
+    }
+
+    let payload;
+    if (raw) {
+      try {
+        payload = JSON.parse(raw);
+      } catch {
+        if (response.ok) {
+          throw new AltalandiError("Altalandi returned an invalid JSON response.", {
+            code: "INVALID_RESPONSE",
+            status: response.status,
+          });
+        }
+      }
+    }
+
+    if (!response.ok) {
+      const status = Number.isInteger(response.status) ? response.status : 0;
+      const statusText = cleanText(response.statusText);
+      const detail = cleanText(errorDetail(payload), apiKey);
+      const suffix = detail || statusText;
+      throw new AltalandiError(
+        `Altalandi API request failed (${status || "unknown status"})${suffix ? `: ${suffix}` : "."}`,
+        { code: "API_ERROR", status, retryAfterMs: retryAfterMs(response) },
+      );
+    }
+
+    if (!payload || typeof payload !== "object" || Array.isArray(payload) || !validShape(payload)) {
+      throw new AltalandiError("Altalandi returned an invalid response shape.", {
+        code: "INVALID_RESPONSE",
+        status: response.status,
+      });
+    }
+
+    return payload;
+  } finally {
+    clearTimeout(timeout);
+  }
+}
+
+/**
+ * Refine English or Icelandic text through the hosted Altalandi API.
+ * Client settings (`apiKey`, `baseUrl`, `timeoutMs`, `fetch`) are never sent in
+ * the JSON body. The full API result is returned without weakening its verdict.
+ */
+export async function refine(text, options = {}) {
+  if (typeof text !== "string" || !text.trim()) {
+    throw new AltalandiError("Altalandi requires non-empty text.", { code: "INVALID_INPUT" });
+  }
+  return post("/v1/refine", requestBody(text, options), options, (p) => typeof p.output === "string");
+}
+
+/**
+ * Refine many short strings in one call (POST /v1/refine/batch): at most 500
+ * items of at most 2,000 characters each, 20,000 characters together. Each item
+ * comes back with its own output and meaning verdict; an item with `error` came
+ * back unchanged and was not billed. Same key, limits and errors as refine().
+ */
+export async function refineBatch(items, options = {}) {
+  if (!Array.isArray(items) || !items.length
+    || !items.every((it) => it && typeof it.text === "string" && (it.id === undefined || typeof it.id === "string"))) {
+    throw new AltalandiError("Altalandi refineBatch requires a non-empty list of { id?, text } items.", {
+      code: "INVALID_INPUT",
+    });
+  }
+  const body = { items: items.map((it) => (it.id === undefined ? { text: it.text } : { id: it.id, text: it.text })) };
+  for (const field of BATCH_REQUEST_FIELDS) {
+    if (options[field] !== undefined) body[field] = options[field];
+  }
+  return post("/v1/refine/batch", body, options, (p) => Array.isArray(p.items)
+    && p.items.every((it) => it && typeof it === "object" && typeof it.output === "string"));
+}
+
+/** Assert that an existing result carries a completed, positive meaning check. */
+export function assertMeaningVerified(result) {
+  if (result?.meaningPreserved !== true) {
+    throw new MeaningVerificationError(result?.meaningPreserved);
+  }
+  return result;
+}
+
+/** Request meaning verification and reject unless the API returns strict true. */
+export async function refineVerified(text, options = {}) {
+  const result = await refine(text, { ...options, preserveMeaning: true });
+  assertMeaningVerified(result);
+  return result;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "altalandi",
-  "version": "0.6.1",
+  "version": "0.6.3",
   "description": "Native-sounding Icelandic from your terminal or AI agent: one-time login, a Claude Code skill, and meaning verification.",
   "type": "module",
   "main": "./client.mjs",

package/report.mjs

@@ -89,6 +89,7 @@ export function reportMarkdown(input, data, options = {}) {
     `| Innfæddni | ${q.nativenessScore ?? "n/a"}/100 |`,
     `| Ritill | ${tier.writer || "standard"} / ${tier.scoring || "?"} |`,
     `| Auðkenni | ${data?.runUrl ? `[${data.id}](${data.runUrl})` : data?.id || "?"} |`,
+    ...(data?.jobUrl ? [`| Verkið | ${data.jobUrl} |`] : []),
     "",
     "## Fyrir", "", fence(input), "",
     "## Eftir", "", fence(data?.output), "",
@@ -154,6 +155,64 @@ export function formatIsk(n) {
 
 const num = (v) => (typeof v === "number" && Number.isFinite(v) ? v : null);
 
+// ── characters (stafir) ─────────────────────────────────────────────────────
+// Billing is in characters. Engines from before the switch send only word
+// units; those are shown as characters too (units × charsPerWord, rounded to
+// tens and marked "um"). The per-100-characters rate is never shown: amounts
+// in krónur and friendly equivalents (an A4 page) only.
+
+/** Characters per word, when an engine does not say (`charsPerWord`). */
+export const CHARS_PER_WORD = 6.5;
+/** A normal A4 page (display only). */
+export const CHARS_PER_A4_PAGE = 3200;
+
+const singular = (n) => { const k = Math.round(Math.abs(n)); return k % 10 === 1 && k % 100 !== 11; };
+
+/** 2690 → "2.690 stafir", 21 → "21 stafur". */
+export function formatChars(n) {
+  return `${formatInt(n)} ${singular(n) ? "stafur" : "stafir"}`;
+}
+
+/** One friendly equivalent: "um 7 A4-síður", "um 1 A4-síða", "innan við hálfa A4-síðu". */
+export function charsEquivalent(n) {
+  const pages = Math.round(Number(n) / CHARS_PER_A4_PAGE);
+  if (pages < 1) return "innan við hálfa A4-síðu";
+  return `um ${formatInt(pages)} ${singular(pages) ? "A4-síða" : "A4-síður"}`;
+}
+
+/** Word units of an older engine as characters, rounded to tens. */
+export function unitsToChars(units, charsPerWord = CHARS_PER_WORD) {
+  return Math.round((Number(units) * charsPerWord) / 10) * 10;
+}
+
+const perWord = (...from) => from.map((o) => num(o?.charsPerWord)).find((v) => v != null && v > 0) ?? CHARS_PER_WORD;
+
+/** The first source with a characters field wins; else the first with word
+ *  units, converted. → { n, approx } or null. */
+function charsOf(sources, charsKey, unitsKey, cpw) {
+  for (const s of sources) if (num(s?.[charsKey]) != null) return { n: s[charsKey], approx: false };
+  for (const s of sources) if (num(s?.[unitsKey]) != null) return { n: unitsToChars(s[unitsKey], cpw), approx: true };
+  return null;
+}
+
+/** Today's free allowance: "ókeypis eftir í dag 9.800 af 15.000 stöfum".
+ *  `billing` is a call's billing block, `after`/`before` the /v1/me answers
+ *  after and before it; any may be null. "" when nothing is known. */
+export function freeCharsText(billing, after = null, before = null) {
+  const cpw = perWord(billing, after, before);
+  const left = charsOf([billing, after], "freeCharsLeftToday", "freeUnitsLeftToday", cpw);
+  const daily = charsOf([after, before], "freeDailyChars", "freeDailyUnits", cpw);
+  // One "um", before the first converted number that is not 0.
+  const um = (c) => (c?.approx && c.n ? "um " : "");
+  if (left && daily) {
+    const [a, b] = um(left) ? ["um ", ""] : ["", um(daily)];
+    return `ókeypis eftir í dag ${a}${formatInt(left.n)} af ${b}${formatInt(daily.n)} ${singular(daily.n) ? "staf" : "stöfum"}`;
+  }
+  if (left) return `ókeypis eftir í dag ${um(left)}${formatChars(left.n)}`;
+  if (daily && daily.n > 0) return `ókeypis ${um(daily)}${formatChars(daily.n)} á dag`;
+  return "";
+}
+
 /**
  * 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
@@ -167,24 +226,21 @@ export function costLines(data, before, after) {
   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 chars = charsOf([b, data], "characters", "units", perWord(b, data, after, before));
+  const charsText = chars ? ` · ${chars.approx ? "um " : ""}${formatChars(chars.n)}` : "";
   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}`);
+  if (charged == null) lines.push(`- Þetta kall: kostnaður óþekktur${charsText}`);
+  else if (charged < 0) lines.push(`- Þetta kall: ekki hægt að reikna (inneignin breyttist á meðan)${charsText}`);
   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}`);
+    ? `- Þetta kall: 0 kr. af inneign${charsText}`
+    : `- Þetta kall: 0 kr., ókeypis dagskammtur${charsText}`);
+  else lines.push(`- Þetta kall: ${formatIsk(charged)} af inneign${exact ? "" : " (mismunur á inneign fyrir og eftir)"}${charsText}`);
 
   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 free = freeCharsText(b, after, before);
   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 (free) parts.push(free);
   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/stjornbord/inneign");
@@ -280,7 +336,9 @@ export function reviewMarkdown(input, data, { before = null, after = null, maxCh
 
   out.push("**Kostnaður**", ...costLines(data, before, after));
   // The run's own page: the text sent, the result, the checks and the review.
-  if (data?.runUrl) out.push(`- Verkið: ${data.runUrl}`);
+  // A call sent as part of a job (--job) links the job first, then this part.
+  if (data?.jobUrl) out.push(`- Verkið: ${data.jobUrl}`);
+  if (data?.runUrl) out.push(`- ${data?.jobUrl ? "Hlutinn" : "Verkið"}: ${data.runUrl}`);
   else if (data?.id) out.push(`- Auðkenni: \`${data.id}\``);
   return out.join("\n") + "\n";
 }
@@ -329,8 +387,12 @@ export function batchReportMarkdown(summary) {
     `| Kaflar | ${count(t.passages)}: ${count(t.changed)} breyttir, ${count(t.unchangedPassages)} þurftu ekki breytingu, `
       + `${count(t.kept)} héldu frumtextanum, ${count(t.failed)} mistókust |`,
     `| Stafir sendir | ${count(t.characters)} |`,
+    ...(Number.isFinite(t.billedCharacters)
+      ? [`| Stafir rukkaðir | ${t.billedCharactersApprox ? "um " : ""}${count(t.billedCharacters)} |`] : []),
     `| Tegund texta | ${cell(summary?.domain || "general")} |`,
     `| Málsnið | ${cell(summary?.register || "neutral")} |`,
+    // The run's one job page (an engine that knows jobs); never one link per call.
+    ...(summary?.jobUrl ? [`| Verkið | ${summary.jobUrl} |`] : []),
   ];
 
   if (summary?.stopped) {