champollion 0.4.0 → 0.5.1

package/lib/methods/openai.js

@@ -19,7 +19,9 @@ import { estimateLlmCost } from './provider-pricing.js';
 
 // The default model, named ONCE — it was previously written twice (here and
 // as an inline fallback in estimateCost()) and the two could drift.
-const DEFAULT_MODEL = 'gpt-4o';
+// A dated snapshot: plain 'gpt-4o' was an alias OpenAI repoints (founder
+// ruling 2026-10-05: exact model ids only, nothing floating).
+const DEFAULT_MODEL = 'gpt-5.4-mini-2026-03-17';
 
 class OpenAIMethod extends DirectLLMMethod {
   constructor(options = {}) {

package/lib/methods/provider-pricing.js

@@ -126,6 +126,9 @@ export const LLM_RATES = {
   // twice the real input rate. Corrected here.
   'gpt-4o':      { provider: 'openai', input: 2.50, output: 10.00, verified: '2026-08-01' },
   'gpt-4o-mini': { provider: 'openai', input: 0.15, output: 0.60,  verified: '2026-08-01' },
+  // The openai default (a dated snapshot, which OpenRouter lists only
+  // undated as openai/gpt-5.4-mini — so this row is what prices it).
+  'gpt-5.4-mini-2026-03-17': { provider: 'openai', input: 0.75, output: 4.50, verified: '2026-10-06' },
 
   // ── Google Gemini ──────────────────────────────────────────────────
   // LAST VERIFIED: 2026-08-01 against the live OpenRouter draw. The values
@@ -135,6 +138,7 @@ export const LLM_RATES = {
   // should have failed. Corrected here.
   'gemini-2.5-flash': { provider: 'gemini', input: 0.30, output: 2.50,  verified: '2026-08-01' },
   'gemini-2.5-pro':   { provider: 'gemini', input: 1.25, output: 10.00, verified: '2026-08-01' },
+  'gemini-3.8-flash': { provider: 'gemini', input: 0.75, output: 3.75,  verified: '2026-10-06' },
 };
 
 /**

package/lib/models.js

@@ -24,77 +24,109 @@ import fs from 'node:fs';
 import path from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { getEnvOrFileVar } from './api-key.js';
+// A cycle (config.js imports this module) that is safe: the default is read
+// only inside requireExactModelId, at call time, never while modules load.
+import { DEFAULT_OPENROUTER_MODEL } from './config.js';
 
 // Per-process cache: provider name → model ID array (or null if fetch failed)
 const _modelCache = new Map();
 
-// Lazy-loaded alias map (loaded once from shared/model-aliases.json)
-let _aliasCache = null;
+// Lazy-loaded retired-name table (loaded once from shared/retired-model-aliases.json)
+let _retiredCache = null;
 
 /**
- * Load the model alias map from shared/model-aliases.json.
+ * Where to look up the models a name could mean — said in every refusal.
+ * `champollion models` lists a direct provider's own names; OpenRouter's
+ * catalogue is its public model list.
+ */
+const MODEL_LIST_HINT = 'List models: https://openrouter.ai/models (OpenRouter slugs), '
+  + 'or champollion models --method <gemini|openai|anthropic> (a direct provider\'s own names).';
+
+/**
+ * Load the RETIRED short model names from shared/retired-model-aliases.json.
  *
- * Resolves the path relative to the monorepo root (two levels up from cli/lib/).
- * Returns an empty object if the file doesn't exist or fails to parse,
- * so callers can always safely check `aliases[name]`.
+ * Founder ruling 2026-10-05: "slugs should be specific, NOT ALIASES — for all
+ * models, all slugs, no aliasing." These names no longer resolve to anything.
+ * The table exists only so a refusal can say which exact slug the old name
+ * used to stand for — it is never used to map a name to a model.
  *
- * @returns {Object<string, string>} Short name → full OpenRouter slug
+ * Prefers the package-bundled copy (cli/shared/, shipped via sync:shared),
+ * then the monorepo-root SSOT for in-repo dev. A missing or unreadable table
+ * leaves the refusal of floating ids intact and only loses the "used to stand
+ * for" hint for a retired name — which then fails as an unknown model at the
+ * provider, still never resolved.
+ *
+ * @returns {Object<string, string>} Retired short name → the slug it stood for
  */
-function _loadAliases() {
-  if (_aliasCache) return _aliasCache;
-
-  try {
-    const __dirname = path.dirname(fileURLToPath(import.meta.url));
-    // Prefer the package-bundled copy (cli/shared/, shipped via the prepack
-    // build-cards-fallback.mjs), then fall back to the monorepo-root SSOT for
-    // in-repo dev. Without the package copy, an installed CLI found no alias map
-    // and `--model <alias>` silently failed to resolve.
-    const aliasPaths = [
-      path.resolve(__dirname, '..', 'shared', 'model-aliases.json'),
-      path.resolve(__dirname, '..', '..', 'shared', 'model-aliases.json'),
-    ];
-    let raw = null;
-    for (const p of aliasPaths) {
-      try { raw = fs.readFileSync(p, 'utf-8'); break; } catch { /* try next */ }
-    }
-    const parsed = raw ? JSON.parse(raw) : {};
-    // Strip metadata keys (e.g., _comment) — only keep actual aliases
-    _aliasCache = {};
-    for (const [key, value] of Object.entries(parsed)) {
-      if (!key.startsWith('_') && typeof value === 'string') {
-        _aliasCache[key] = value;
-      }
+function _loadRetiredAliases() {
+  if (_retiredCache) return _retiredCache;
+  _retiredCache = Object.create(null);
+  const __dirname = path.dirname(fileURLToPath(import.meta.url));
+  const candidates = [
+    path.resolve(__dirname, '..', 'shared', 'retired-model-aliases.json'),
+    path.resolve(__dirname, '..', '..', 'shared', 'retired-model-aliases.json'),
+  ];
+  for (const p of candidates) {
+    let raw;
+    try { raw = fs.readFileSync(p, 'utf-8'); } catch { continue; }
+    const retired = JSON.parse(raw).retired || {};
+    for (const [key, value] of Object.entries(retired)) {
+      if (typeof value === 'string') _retiredCache[key] = value;
     }
-  } catch {
-    _aliasCache = {};
+    break;
   }
+  return _retiredCache;
+}
 
-  return _aliasCache;
+/**
+ * True for a floating id — one that names whatever model a provider points it
+ * at today, so a run could not say which model translated: OpenRouter's
+ * "~vendor/…" router ids and any "…-latest" / "…:latest" name.
+ *
+ * @param {string} id
+ * @returns {boolean}
+ */
+function isFloatingModelId(id) {
+  return typeof id === 'string' && (id.trim().startsWith('~') || /[-:]latest$/i.test(id.trim()));
 }
 
 /**
- * Resolve a model name or alias to a full OpenRouter slug.
+ * Check that a configured model is an EXACT model slug, and return it unchanged.
  *
- * Resolution order:
- *   1. If contains '/' → already a full slug, pass through
- *   2. Check shared/model-aliases.json for a matching alias
- *   3. Pass through as-is (user may know what they're doing)
+ * Founder ruling 2026-10-05: every model is named by its exact provider slug
+ * ("google/gemini-3.5-flash", "anthropic/claude-sonnet-4.6", or a direct
+ * provider's own exact name, "gpt-5.5"). Nothing resolves a short name:
+ *   - a retired alias ("gemini-flash", "gpt", …) is REFUSED, naming the exact
+ *     slug it used to stand for;
+ *   - a floating id ("~google/gemini-flash-latest", "…-latest") is REFUSED.
+ * Anything else passes through as written — the provider judges whether the
+ * model exists (direct providers also check it against their model list).
  *
- * @param {string} nameOrSlug - User-provided model identifier
- * @returns {string} Full OpenRouter model slug
+ * @param {string|null|undefined} id - The model as written
+ * @param {{ from?: string|null }} [where] - Where it was set ("from --model")
+ * @returns {string|null|undefined} The same id
+ * @throws {Error} code CHAMPOLLION_MODEL_ID
  */
-function resolveModel(nameOrSlug) {
-  if (!nameOrSlug || typeof nameOrSlug !== 'string') return nameOrSlug;
-
-  // Already a full slug (contains provider prefix)
-  if (nameOrSlug.includes('/')) return nameOrSlug;
-
-  // Check aliases
-  const aliases = _loadAliases();
-  if (aliases[nameOrSlug]) return aliases[nameOrSlug];
-
-  // Pass through — could be a provider-specific model name (e.g., gemini-2.0-flash)
-  return nameOrSlug;
+function requireExactModelId(id, { from = null } = {}) {
+  if (!id || typeof id !== 'string') return id;
+  const at = from ? ` (${from})` : '';
+  const retired = _loadRetiredAliases();
+  if (Object.prototype.hasOwnProperty.call(retired, id)) {
+    const err = new Error(
+      `"${id}"${at} is not a model id — Champollion takes exact model slugs only, no aliases. `
+      + `Did you mean ${retired[id]} (what "${id}" used to stand for)? ${MODEL_LIST_HINT}`);
+    err.code = 'CHAMPOLLION_MODEL_ID';
+    throw err;
+  }
+  if (isFloatingModelId(id)) {
+    const err = new Error(
+      `"${id}"${at} is a floating model id — it names whatever model the provider points it at today, `
+      + 'so a run could not say which model translated. Champollion takes exact model slugs only: '
+      + `name the model itself (e.g. "${DEFAULT_OPENROUTER_MODEL}", the CLI default). ${MODEL_LIST_HINT}`);
+    err.code = 'CHAMPOLLION_MODEL_ID';
+    throw err;
+  }
+  return id;
 }
 
 /**
@@ -183,7 +215,10 @@ async function fetchAvailableModels(provider, apiKey) {
   if (cached !== undefined) return cached;
 
   try {
-    const models = await config.fetch(apiKey);
+    // Floating ids ("gemini-flash-latest", "chatgpt-4o-latest") are listed by
+    // the providers but refused everywhere (requireExactModelId) — never offer
+    // one, so neither `champollion models` nor init's picker suggests it.
+    const models = (await config.fetch(apiKey))?.filter(id => !isFloatingModelId(id)) ?? null;
     if (models && models.length > 0) {
       _modelCache.set(provider, models);
       return models;
@@ -258,7 +293,8 @@ function clearModelCache() {
 
 export {
   fetchAvailableModels,
-  resolveModel,
+  requireExactModelId,
+  isFloatingModelId,
   resolveProviderApiKey,
   getProviderLabel,
   getProviderEnvVar,

package/lib/pairs.js

@@ -22,7 +22,7 @@ import { resolveTargetScript, validateScriptFallback, converterKeyForLocale } fr
 import { getMethod, METHOD_REGISTRY } from './translate.js';
 import { COACHED_PROVIDERS, normalizeProvider } from './methods/llm-coached.js';
 import { DEFAULT_OPENROUTER_MODEL, DEFAULT_BATCH_SIZE, DEFAULT_MAX_RETRIES } from './config.js';
-import { resolveModel } from './models.js';
+import { requireExactModelId } from './models.js';
 import { output } from './output.js';
 import { tmMethodKey } from './tm.js';
 import { PLAIN_LLM_METHODS } from './methods/prompt-methods.js';
@@ -169,10 +169,10 @@ const MODEL_ID_TRANSPORTS = new Set(['openai', 'anthropic', 'gemini', 'local']);
 /**
  * The model id a pair's transport is sent, as written in the config or on
  * --model:
- *   - OpenRouter (llm, llm-coached by default): an alias from
- *     shared/model-aliases.json becomes its full id ("gemini-flash" →
- *     "google/gemini-3.5-flash"). --model's alias used to reach OpenRouter
- *     unresolved, as "gemini-flash".
+ *   - OpenRouter (llm, llm-coached by default): the exact slug as written.
+ *     A retired alias ("gemini-flash") or a floating id ("~google/…-latest")
+ *     THROWS, naming the exact slug to write (founder ruling 2026-10-05:
+ *     exact slugs only, no aliasing — lib/models.js requireExactModelId).
  *   - A direct provider (openai, anthropic, gemini — as a method or as the
  *     provider of llm-coached): its own name ("openai/gpt-5.5" → "gpt-5.5");
  *     an id it has no name for ("google/…" on openai) THROWS, naming a model
@@ -185,12 +185,12 @@ const MODEL_ID_TRANSPORTS = new Set(['openai', 'anthropic', 'gemini', 'local']);
  * @param {string|null} provider - Resolved transport (null for non-routed methods)
  * @param {string|null} [from] - Where the id was set, for a refusal
  * @returns {string|null}
- * @throws {Error} code CHAMPOLLION_MODEL_ROUTE (the caller prefixes the pair)
+ * @throws {Error} code CHAMPOLLION_MODEL_ROUTE or CHAMPOLLION_MODEL_ID (the caller prefixes the pair)
  */
 function modelIdForTransport(model, method, provider = null, from = null) {
   if (!model) return model;
   const transport = PROVIDER_ROUTED_METHODS.has(method) ? (provider || 'openrouter') : method;
-  if (transport === 'openrouter') return resolveModel(model);
+  if (transport === 'openrouter') return requireExactModelId(model, { from });
   if (MODEL_ID_TRANSPORTS.has(transport)) return new METHOD_REGISTRY[transport]().resolveModelId(model, { from });
   return model;
 }
@@ -203,7 +203,7 @@ function resolveModelNamed(where, from, explicitModel, method, globalDefault, pr
   try {
     return resolveModelForPair(explicitModel, method, globalDefault, provider, providerModel, from);
   } catch (err) {
-    if (err.code === 'CHAMPOLLION_MODEL_ROUTE') err.message = `${where}: ${err.message}`;
+    if (err.code === 'CHAMPOLLION_MODEL_ROUTE' || err.code === 'CHAMPOLLION_MODEL_ID') err.message = `${where}: ${err.message}`;
     throw err;
   }
 }

package/lib/segment.js

@@ -73,7 +73,10 @@ const SEGMENT_MARKER_SUFFIX = '⟧';
 function hasTranslatableText(text) {
   const stripped = text
     .replace(PLACEHOLDER_TOKEN_REGEX, '')
-    .replace(IMPORT_EXPORT_LINE_REGEX, '');
+    .replace(IMPORT_EXPORT_LINE_REGEX, '')
+    // An HTML comment is a note to editors, never shown: not sent, not billed
+    // (dogfood 2026-10-05 — comment-only blocks were translated and gated).
+    .replace(/<!--[\s\S]*?-->/g, '');
   return /[\p{L}\p{N}]/u.test(stripped);
 }
 
@@ -186,10 +189,21 @@ function buildBlockBatchPrompt(blockTexts, langConfig, options = {}) {
     .map((text, i) => `${SEGMENT_MARKER_PREFIX}${i}${SEGMENT_MARKER_SUFFIX}\n${text}`)
     .join('\n\n');
 
+  // A second ask for segments the quality check refused (lib/fallback.js
+  // retryRefusedBlocks): the model is told why, and that text which is
+  // correct as written may come back unchanged.
+  const notes = langConfig.retryNotes instanceof Map
+    ? blockTexts.map((text, i) => (langConfig.retryNotes.has(text) ? `- Segment ${i}: ${langConfig.retryNotes.get(text)}` : null)).filter(Boolean)
+    : [];
+  const retryBlock = notes.length > 0
+    ? `\nYour previous translation of these segments was refused by an automatic quality check, for the reason given:\n${notes.join('\n')}\n`
+      + `Translate each one again. If a segment is correct exactly as written in ${sourceLanguageName} — a name, title, citation, identifier, code or data — return it unchanged.\n`
+    : '';
+
   return `You are translating Markdown content from ${sourceLanguageName} to ${langConfig.name}. The document was split into ${blockTexts.length} numbered segment(s); segments not shown are already translated.
 ${contextBlock}${titleBlock}
 Register/tone: ${langConfig.register}
-
+${retryBlock}
 Rules:
 - Translate ALL human-readable text in every segment.
 - Preserve ALL Markdown formatting: headers (#), bold (**), italic (*), links, images, lists, blockquotes, tables, admonitions (:::), etc.${placeholderRule}
@@ -285,8 +299,8 @@ function parseBlockBatchResponse(response, expectedCount, opts = {}) {
  *   1. Send the full batch. Missing marker(s)? →
  *   2. ONE retry with only the missing segments (a fresh, smaller batch —
  *      different neighbors, usually enough). Still missing? →
- *   3. Honest fallback: `fallbackPrefix + source` for just those segments
- *      (the established '[EN] ' doctrine — visible, never silent).
+ *   3. The source block stands for just those segments, unmarked — the
+ *      caller reports it, records it and asks again on the next sync.
  *
  * The CALLER's contract for fallen-back segments: never store them in the
  * TM (an error cached is an error forever) and never advance the file's
@@ -297,13 +311,12 @@ function parseBlockBatchResponse(response, expectedCount, opts = {}) {
  * @param {string[]} p.texts - Protected block texts to translate
  * @param {(texts: string[]) => string} p.buildPrompt - Batch prompt builder
  * @param {(prompt: string) => Promise<string|null>} p.callModel - One API call
- * @param {string} p.fallbackPrefix - e.g. '[EN] ' — prepended to source text
  * @returns {Promise<{blocks: string[], fellBack: number[]}>} index-aligned
  *   translations; `fellBack` lists indexes that carry the fallback
  * @throws {Error} If the FIRST call returns nothing at all, or on
  *   duplicate/unknown markers (untrustworthy mapping)
  */
-async function translateBlockBatchResilient({ texts, buildPrompt, callModel, fallbackPrefix }) {
+async function translateBlockBatchResilient({ texts, buildPrompt, callModel }) {
   const first = await callModel(buildPrompt(texts));
   if (!first) {
     throw new Error('block-batch translation returned no results');
@@ -331,8 +344,10 @@ async function translateBlockBatchResilient({ texts, buildPrompt, callModel, fal
     }
   }
 
+  // Still missing after the retry: the source block stands, unmarked; the
+  // caller records it, does not cache it and does not advance the lock.
   for (const i of stillMissing) {
-    blocks[i] = fallbackPrefix + texts[i];
+    blocks[i] = texts[i];
   }
   return { blocks, fellBack: stillMissing };
 }

package/lib/validate.js

@@ -443,6 +443,106 @@ function isProtectedTermValue(value, protectedTerms = []) {
   return rest.replace(/\{[^}]*\}/g, '').replace(/[\d\s\p{P}\p{S}]/gu, '').length === 0;
 }
 
+/**
+ * The gate's version. A refusal is remembered with the version that made it
+ * (lib/content-refusals.js, lib/locale-state.js), and a hold made by an
+ * earlier gate lifts by itself: what an over-strict gate refused is asked
+ * again once the gate is fixed, instead of staying in the source language
+ * until someone names it for a redo. Bump it whenever a check is loosened.
+ *   2 — 2026-10-05: names with citations/anchors, reference entries, tables,
+ *       short titles and source-shown fullwidth letters stopped being refused.
+ */
+const GATE_VERSION = 2;
+
+/**
+ * Refusals that may be the model keeping text that is correct as written —
+ * a name, title, citation, identifier or code: the source handed back, or
+ * Latin script kept in a non-Latin target. Told why and asked again, a model
+ * that gives the same answer twice is taken at its word (lib/fallback.js
+ * retryRefusedBlocks), as the key-value lane takes a name it is asked about
+ * twice (LATIN_NAME_OR_LABEL). Every other refusal (repetition, length,
+ * hollowing, damaged markup, fullwidth disguise) is never accepted this way.
+ *
+ * @param {string|null} reason
+ * @returns {boolean}
+ */
+function isKeepAsWrittenFault(reason) {
+  if (typeof reason !== 'string') return false;
+  return reason.startsWith('source echo')
+    || reason === LATIN_NAME_OR_LABEL
+    || reason.startsWith('wrong script (ASCII-only');
+}
+
+/**
+ * How much longer than its source a value may be before the length ratio
+ * counts. The ratio is meaningless on a tiny source: "FAQ" → "Preguntas
+ * frecuentes" is 6.7x and correct (dogfood 2026-10-05, a docs page title),
+ * while "Feast" → a whole sentence still grows by far more than this.
+ */
+const SHORT_SOURCE_LENGTH_SLACK = 20;
+
+/**
+ * The part of a string that would need translating, for the "short name kept
+ * as written" rule: inline code, quoted strings, parentheticals and Markdown
+ * block markers removed. "### METEOR (Banerjee & Lavie, 2005)" is the name
+ * METEOR, and "## Hugo (TOML / YAML / Markdown)" the name Hugo — both were
+ * refused as source echo on the whole string's length (dogfood 2026-10-05).
+ *
+ * @param {string} text
+ * @returns {string}
+ */
+function nameCore(text) {
+  return String(text)
+    .replace(/^[ \t]*(?:#{1,6}[ \t]+|[-*+][ \t]+|\d{1,9}[.)][ \t]+)/, '')
+    .replace(/\{#[^}\s]+\}\s*$/, ' ')
+    .replace(/`[^`]*`/g, ' ')
+    .replace(/"[^"]*"|“[^”]*”|「[^」]*」/g, ' ')
+    .replace(/\([^()]*\)|（[^（）]*）/g, ' ')
+    .replace(/\s+/g, ' ')
+    .trim();
+}
+
+/**
+ * A reference-list entry — numbered, with a year or a link, and a quoted or
+ * italic title: "4. Snover, M., … (2006). \"A Study of …\" *Proceedings …*".
+ * Cited works are kept as published, so the same text back is correct, not
+ * an echo (dogfood 2026-10-05: twelve references of the scoring spec were
+ * refused and published with the fallback prefix).
+ *
+ * @param {string} text
+ * @returns {boolean}
+ */
+function isBibliographicEntry(text) {
+  const t = String(text).trim();
+  // A reference list in one block: every entry must be one.
+  if (t.includes('\n')) {
+    const lines = t.split('\n').map(l => l.trim()).filter(Boolean);
+    return lines.length > 1 && lines.every(l => !l.includes('\n') && isBibliographicEntry(l));
+  }
+  return /^(?:\[?[A-Z]?\d{1,3}\]?[.)]?|[-*+])\s+\S/.test(t)
+    && (/\(\d{4}[a-z]?\)/.test(t) || /\]\(https?:\/\//.test(t))
+    && (/"[^"]{8,}"|“[^”]{8,}”/.test(t) || /\*[^*]{8,}\*/.test(t));
+}
+
+/**
+ * A Markdown table measured as its cells' text: delimiter rows dropped and
+ * pipes turned to spaces. The delimiter row ("|---|---|") is repetition by
+ * construction, so a table whose model output padded it differently was
+ * refused as a repetition hallucination (dogfood 2026-10-05, four tables).
+ * Anything that is not a table comes back unchanged.
+ *
+ * @param {string} text
+ * @returns {string}
+ */
+function tableProse(text) {
+  const lines = String(text).split('\n');
+  if (!lines.some((l) => /^\s*\|/.test(l))) return text;
+  return lines
+    .filter((l) => !/^\s*\|?(?:\s*:?-{3,}:?\s*\|)+\s*:?-{0,}:?\s*$/.test(l))
+    .map((l) => (/^\s*\|/.test(l) ? l.replace(/\|/g, ' ').replace(/[ \t]+/g, ' ').trim() : l))
+    .join('\n');
+}
+
 /**
  * Why the quality gate refuses one Markdown block or front-matter field, or
  * null when it passes — the key-value gate's own checks (empty, source echo,
@@ -462,6 +562,9 @@ function isProtectedTermValue(value, protectedTerms = []) {
  */
 function contentGateFault(source, value, pairConfig = {}) {
   if (typeof source !== 'string' || typeof value !== 'string') return null;
+  if (value === source && isBibliographicEntry(source)) return null;
+  source = tableProse(source);
+  value = tableProse(value);
   const { failures } = validateTranslations({ block: value }, { block: source }, pairConfig || {},
     { prose: true, acceptLatinNames: true, acceptPluralGaps: true });
   return failures.length > 0 ? failures[0].reason : null;
@@ -547,8 +650,10 @@ function validateTranslations(translations, sourceFlat, pairConfig, options = {}
     //     it is taken at its word as a name (acceptLatinNames) and cached, so
     //     it is never re-billed. One bounded retry — never a retry loop.
     if (translated === source) {
-      const asciiRatio = source.replace(/[^\x20-\x7E]/g, '').length / Math.max(source.length, 1);
-      const isShortAscii = source.length <= 30 && asciiRatio > 0.8;
+      const core = nameCore(source);
+      const asciiRatio = core.replace(/[^\x20-\x7E]/g, '').length / Math.max(core.length, 1);
+      // Nothing left once code, quotes and parentheticals go: nothing to translate.
+      const isShortAscii = core.length === 0 || (core.length <= 30 && asciiRatio > 0.8);
       if (!isShortAscii) {
         failures.push({ key, reason: 'source echo (identical to English)', value: translated });
         continue;
@@ -682,7 +787,7 @@ function validateTranslations(translations, sourceFlat, pairConfig, options = {}
     // Check 4: Length ratio — catches padding and truncation
     if (source.length > 0) {
       const ratio = translated.length / source.length;
-      if (ratio > thresholds.maxLengthRatio) {
+      if (ratio > thresholds.maxLengthRatio && translated.length - source.length > SHORT_SOURCE_LENGTH_SLACK) {
         failures.push({
           key,
           reason: `length inflation (${ratio.toFixed(1)}x source, max ${thresholds.maxLengthRatio}x)`,
@@ -719,7 +824,7 @@ function validateTranslations(translations, sourceFlat, pairConfig, options = {}
     // Fullwidth Latin letters ("Ｂｏｏｋ ａｎ ａｐｐｏｉｎｔｍｅｎｔ") outside CJK typography:
     // English in disguise, whatever the target's script. Never a name — a
     // name kept as written is in plain letters.
-    if (hasForeignFullwidthLatin(translated, targetLocale)) {
+    if (hasForeignFullwidthLatin(translated, targetLocale) && !hasForeignFullwidthLatin(source, targetLocale)) {
       failures.push({
         key,
         reason: `wrong script (fullwidth Latin letters in a ${targetLocale} value — English in disguise, not a translation)`,
@@ -733,8 +838,9 @@ function validateTranslations(translations, sourceFlat, pairConfig, options = {}
         .replace(/\{[^}]*\}/g, '')   // ICU placeholders
         .replace(/[\d\s\p{P}\p{S}]/gu, '')  // digits, whitespace, punctuation, symbols
         .trim();
-      const asciiRatio = source.replace(/[^\x20-\x7E]/g, '').length / Math.max(source.length, 1);
-      const isShortAscii = source.length <= 30 && asciiRatio > 0.8;
+      const core = nameCore(source);
+      const asciiRatio = core.replace(/[^\x20-\x7E]/g, '').length / Math.max(core.length, 1);
+      const isShortAscii = core.length === 0 || (core.length <= 30 && asciiRatio > 0.8);
       // Letters classified by Unicode script: accented Latin is Latin too
       // (an ASCII test passed "Thánk yóú" in a Russian catalog).
       if (translatableText.length > 0 && isLatinOnly(translated, targetLocale)) {
@@ -1358,6 +1464,12 @@ export {
   LATIN_NAME_OR_LABEL,
   foldForEchoCompare,
   letterWordCount,
+  nameCore,
+  GATE_VERSION,
+  isKeepAsWrittenFault,
+  isBibliographicEntry,
+  tableProse,
+  SHORT_SOURCE_LENGTH_SLACK,
   isDisguisedEcho,
   pluralBranchEcho,
   MIN_FOLDED_ECHO_WORDS,

package/lib/verify.js

@@ -57,6 +57,7 @@ import { pluralGaps, pluralCategoryUse, describeCategories, parseMessage, hasBra
 import { pluralCategoriesFor, pluralExtraKeys } from './plurals.js';
 import { poPluralFindings, poPluralSlots } from './po.js';
 import { output } from './output.js';
+import { isPendingLock } from './content-refusals.js';
 
 /**
  * The target locales a `--pair` value names (e.g. "en:fr,en:de"), resolved
@@ -846,9 +847,19 @@ async function verifyLocales(config, cwd, options = {}) {
     // (a heading turned into a sentence): sync refuses them since Round 7;
     // what is on disk from before is named here, with the one repair.
     for (const w of contentGateWarnings(locale, contentItems, pairConfigs.get(locale) || { target: locale },
-      pairOf.get(locale) || `${config.inputLocale}:${locale}`, config.fallbackPrefix || '[EN] ')) {
+      pairOf.get(locale) || `${config.inputLocale}:${locale}`, config.fallbackPrefix || '[EN] ', tm)) {
       localeWarnings.push(w);
     }
+    // Pages written with parts left in the source language — what the gate
+    // refused twice (asked again with the reason). No marker is written into
+    // the page, so the content lock says it: `pending:<hash>`.
+    const pendingPages = pendingContentPages(cwd, locale);
+    if (pendingPages.length > 0) {
+      const pair = pairOf.get(locale) || `${config.inputLocale}:${locale}`;
+      localeWarnings.push(`${pendingPages.length} page(s) with parts left in the source language, refused by the quality gate `
+        + `(${pendingPages.slice(0, 3).join(', ')}${pendingPages.length > 3 ? ', …' : ''}) — sync names each part; `
+        + `ask again: \`${contentRedoCommand(pendingPages[0], { pair })}\`${pendingPages.length > 1 ? ' (one per page)' : ''}`);
+    }
 
     output.raw(`  ── ${locale} ──────────────────────────────────────`);
 
@@ -1340,6 +1351,26 @@ function contentItemsFor(config, cwd, locale, { only = null } = {}) {
   return items;
 }
 
+/**
+ * Content pages of one locale whose lock entry is `pending:<hash>` (written
+ * with parts left in the source language — lib/content-refusals.js), as sync
+ * names them. Read straight from the content lock; never fails.
+ *
+ * @param {string} cwd
+ * @param {string} locale
+ * @returns {string[]}
+ */
+function pendingContentPages(cwd, locale) {
+  let lock = {};
+  try { lock = JSON.parse(fs.readFileSync(path.join(cwd, '.champollion-content.lock'), 'utf-8')); } catch { return []; }
+  const pages = [];
+  for (const [key, value] of Object.entries(lock)) {
+    if (!isPendingLock(value) || !key.endsWith(`:${locale}`)) continue;
+    pages.push(key.slice(0, -(locale.length + 1)).replace(/^docusaurus:/, ''));
+  }
+  return pages.sort();
+}
+
 /**
  * The command that re-translates one content file — the ONE repair sync and
  * verify both print for a content finding. `--redo files:` matches the path
@@ -1365,10 +1396,15 @@ function contentRedoCommand(file, { pair = null } = {}) {
  *
  * @returns {string[]} warnings
  */
-function contentGateWarnings(locale, items, pairConfig, pair, fallbackPrefix) {
+function contentGateWarnings(locale, items, pairConfig, pair, fallbackPrefix, tm = null) {
   const byFile = new Map();
+  const tmKeys = tm ? tmKeysForPair(pairConfig) : [];
   for (const it of items || []) {
     if (typeof it.value !== 'string' || it.value.startsWith(fallbackPrefix)) continue;
+    // What sync accepted and cached for this source — e.g. a name or citation
+    // the model kept as written when asked again with the reason — is not
+    // judged again here (it would name a deliberate answer as a fault).
+    if (tm && tmHoldsValue(tm, it.source, locale, tmKeys, it.value)) continue;
     const reason = contentGateFault(it.source, it.value, pairConfig);
     if (!reason) continue;
     const rest = it.key.slice('content:'.length);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "champollion",
-  "version": "0.4.0",
+  "version": "0.5.1",
   "description": "Research-grade translation engine for i18n projects. Pluggable methods, per-pair quality tiers, and deterministic script converters. Supports JSON (next-intl, i18next), TOML, and YAML (Hugo).",
   "type": "module",
   "bin": {