champollion 0.4.0 → 0.5.0

package/lib/autofix.js

@@ -385,14 +385,16 @@ function wrapUnsupportedReason(file) {
  * (this used to look only for `<locale>.json`, so TOML/YAML projects lost
  * every extracted key without a word).
  *
- * Source gets the extracted text; each EXISTING target file gets the same
- * keys with an "[EN] " placeholder, which the next sync translates. Keys
- * already present are never overwritten.
+ * Source gets the extracted text. Target files are left alone: the next sync
+ * sees the new keys missing there and translates them (an "[EN] " placeholder
+ * used to be written into each target, and shipped if no sync followed —
+ * nothing marked untranslated is written any more). Keys already present are
+ * never overwritten.
  *
  * @param {object[]} fixes - Array of { key, text } from processFile
  * @param {{ path: string, format: string }} sourceFile - Source locale file
- * @param {Array<{ path: string, format: string }>} targetFiles - Target locale files
- * @returns {{ source: boolean, targets: number }} What was written
+ * @param {Array<{ path: string, format: string }>} targetFiles - Target locale files (checked, not written)
+ * @returns {{ source: boolean, targets: number }} What was written (targets: always 0)
  */
 function addKeysToLocales(fixes, sourceFile, targetFiles = []) {
   const written = { source: false, targets: 0 };
@@ -435,10 +437,6 @@ function addKeysToLocales(fixes, sourceFile, targetFiles = []) {
   };
 
   written.source = addTo(sourceFile, '');
-  // Use [EN] prefix for target locales as untranslated markers
-  for (const target of targetFiles) {
-    if (addTo(target, '[EN] ')) written.targets++;
-  }
   return written;
 }
 

package/lib/commands/init.js

@@ -32,7 +32,7 @@ import readline from 'node:readline';
 import { CONFIG_FILENAMES, DEFAULT_OPENROUTER_MODEL, DEFAULT_BATCH_SIZE, DEFAULT_TEMPERATURE, DEFAULT_COACHED_TEMPERATURE, detectDocusaurus } from '../config.js';
 import { DEFAULT_REGISTERS, getLanguageCard, getRegisterPresets, isMethodSupported, resolveCode, summarizeGenderGuidance, isPrivateUseCode } from '../registers.js';
 import { getConverterInfo, resolveTargetScript, converterKeyForLocale } from '../scripts.js';
-import { fetchAvailableModels, resolveProviderApiKey, isListableProvider, getProviderLabel } from '../models.js';
+import { fetchAvailableModels, resolveProviderApiKey, isListableProvider, getProviderLabel, requireExactModelId } from '../models.js';
 import { showCommandHelp } from '../command-help.js';
 import { output } from '../output.js';
 import { flutterLocaleLines } from '../flutter-locales.js';
@@ -953,20 +953,21 @@ async function pickModelForProvider(rl, method, presetModel = null) {
   }
   console.log('');
 
-  const modelChoice = await ask(rl, 'Choose (number or model ID)', '1');
-  const modelNum = parseInt(modelChoice, 10);
-
-  if (modelNum >= 1 && modelNum <= models.length) {
-    return models[modelNum - 1];
-  }
-
-  // User typed a model slug directly — use as-is
-  if (modelChoice.trim()) {
-    return modelChoice.trim();
+  // A typed id is checked here, as --model is: an alias or a floating id is
+  // refused with the exact slug to write, and asked again — not written into
+  // the config to fail at the first sync.
+  for (;;) {
+    const modelChoice = await ask(rl, 'Choose (number or model ID)', '1');
+    const modelNum = parseInt(modelChoice, 10);
+    if (modelNum >= 1 && modelNum <= models.length) return models[modelNum - 1];
+    if (!modelChoice.trim()) return models[0];
+    try {
+      requireExactModelId(modelChoice.trim(), { from: 'typed' });
+      return modelChoice.trim();
+    } catch (err) {
+      console.log(`  ${err.message}`);
+    }
   }
-
-  // Empty input — use the first model from the list
-  return models[0];
 }
 
 /**
@@ -1777,6 +1778,11 @@ function validateInitFlags(args) {
     return `--endpoint applies to --method api (a champollion API endpoint)${args.method ? `, not --method ${args.method}` : ''}. `
       + 'For an OpenAI-compatible server use --method local and LOCAL_API_BASE.';
   }
+  // Exact model slugs only (founder ruling 2026-10-05): a retired alias or a
+  // floating id is refused before init writes it into the config.
+  if (typeof args.model === 'string' && args.model) {
+    try { requireExactModelId(args.model, { from: 'from --model' }); } catch (err) { return err.message; }
+  }
   if (args['accepts-instructions'] != null) {
     if (args.method !== API_METHOD) return '--accepts-instructions applies to --method api.';
     if (!['true', 'false'].includes(String(args['accepts-instructions']))) {

package/lib/commands/wrap.js

@@ -127,9 +127,9 @@ async function run(args, cwd) {
 
   // Add extracted keys to locale files (only if not dry-run)
   if (!isDry && allFixes.length > 0) {
-    const written = addKeysToLocales(allFixes, destination.source, destination.targets);
+    addKeysToLocales(allFixes, destination.source, destination.targets);
     output.info(`Added ${allFixes.length} key(s) to ${destination.source.rel}`
-      + (written.targets > 0 ? ` and ${written.targets} target file(s) (as [EN] placeholders for the next sync)` : ''));
+      + (destination.targets.length > 0 ? ' — run `champollion sync` to translate them into each target' : ''));
   } else if (isDry && allFixes.length > 0) {
     output.info(`Would add ${allFixes.length} key(s) to ${destination.source.rel}`);
   }

package/lib/config.js

@@ -14,7 +14,7 @@
 import fs from 'node:fs';
 import path from 'node:path';
 import { DEFAULT_REGISTERS, getLanguageCard, getRegister, resolveCode } from './registers.js';
-import { resolveModel } from './models.js';
+import { requireExactModelId } from './models.js';
 import { validateNoTranslateConfig } from './no-translate.js';
 import { output } from './output.js';
 import { splitKeyList } from './redo.js';
@@ -65,6 +65,31 @@ const DEFAULT_METHOD_CONCURRENCY = 4;
 const EST_INPUT_TOKENS_PER_KEY = 200;
 const EST_OUTPUT_TOKENS_PER_KEY = 30;
 const EST_CHARS_PER_KEY = 25;
+// Markdown content priced by a token-billed method (an LLM): one key-unit per
+// 60 source characters, not 25. A UI key carries its share of the prompt on
+// every 25-char slice; a content batch carries the prompt once per page and
+// the text itself is ~4 characters a token. Measured on champollion.dev with
+// google/gemini-3.8-flash (2026-10-05): at 25 the estimate ran 2.8x over the
+// bill for 95 Spanish pages and 8.2x over for one Arabic page; at 60 it is
+// ~1.2x and ~3.4x — still above the bill, as the --max-cost cap needs.
+// Character-billed engines (DeepL, Google, Microsoft) keep 25: for them the
+// key-unit converts back to the exact characters they bill.
+const EST_CONTENT_CHARS_PER_KEY_TOKEN_PRICED = 60;
+const TOKEN_PRICED_METHODS = new Set(['llm', 'llm-coached', 'openai', 'anthropic', 'gemini', 'local']);
+
+/**
+ * Key-units for a run of Markdown source characters, priced by `pairConfig`'s
+ * method (see EST_CONTENT_CHARS_PER_KEY_TOKEN_PRICED).
+ *
+ * @param {number} chars
+ * @param {object} [pairConfig]
+ * @returns {number}
+ */
+function contentKeyUnits(chars, pairConfig = {}) {
+  const perKey = TOKEN_PRICED_METHODS.has(pairConfig?.method || 'llm')
+    ? EST_CONTENT_CHARS_PER_KEY_TOKEN_PRICED : EST_CHARS_PER_KEY;
+  return Math.ceil(chars / perKey);
+}
 
 const DEFAULTS = {
   version: 3,
@@ -446,8 +471,12 @@ function resolveConfig(cliArgs = {}, cwd = process.cwd()) {
     config.localesDir = compiled.base;
   }
 
-  // Resolve model alias (e.g., "gemini-flash" → "google/gemini-3.5-flash")
-  config.model = resolveModel(config.model);
+  // Exact model slugs only (founder ruling 2026-10-05): a retired alias
+  // ("gemini-flash") or a floating id ("~google/gemini-flash-latest") is
+  // refused here, naming the slug to write — it never resolves to a model.
+  // The file's own model is checked too: a pair's fallback runs on it.
+  requireExactModelId(config.model, { from: config._modelOverride ? 'from --model' : 'from the top-level "model"' });
+  if (config._modelOverride) requireExactModelId(config._fileModel, { from: 'from the top-level "model"' });
 
   // Coaching file: read the file contents into coachingPrompt if coachingFile is set.
   // This allows users to maintain coaching prompts as separate text files rather
@@ -700,6 +729,8 @@ export {
   EST_INPUT_TOKENS_PER_KEY,
   EST_OUTPUT_TOKENS_PER_KEY,
   EST_CHARS_PER_KEY,
+  EST_CONTENT_CHARS_PER_KEY_TOKEN_PRICED,
+  contentKeyUnits,
   DEFAULT_MAX_RETRIES,
   DEFAULT_METHOD_CONCURRENCY,
 };

package/lib/content-estimate.js

@@ -55,9 +55,10 @@ export function translatableBlockSources(body) {
  * @param {ReturnType<import('./content-refusals.js').contentHolds>|null} [args.holds] -
  *   What the quality gate refused before (lib/content-refusals.js): a block
  *   or field the pair's method refused is not sent to it (held, or the
- *   fallback's — which this estimate does not price); a held front-matter
- *   field — or a held page body in 'page' segmentation — holds its whole
- *   page, so nothing of it is billed
+ *   fallback's — which this estimate does not price); a held page body in
+ *   'page' segmentation holds its whole page, so nothing of it is billed. A
+ *   held front-matter field keeps its source text and the rest of the page
+ *   is still sent (since 2026-10-05)
  * @returns {{ billedChars: number, totalChars: number }}
  */
 export function billableContentChars({ tm, code, tmKey, fallbackTmKey = null, fields, body, segMode, blockSources, holds = null }) {
@@ -71,8 +72,7 @@ export function billableContentChars({ tm, code, tmKey, fallbackTmKey = null, fi
     totalChars += text.length;
     if (cached(text)) continue;
     const hold = holds ? holds.field(field, text) : 'send';
-    if (hold === 'held') pageHeld = true;
-    else if (hold === 'send') billedChars += text.length;
+    if (hold === 'send') billedChars += text.length;
   }
 
   if (body.trim()) {

package/lib/content-refusals.js

@@ -16,7 +16,7 @@
  * own entries), one entry per (page × locale) that has refusals:
  *
  *   "refused:<manifestKey>": {
- *     "block:<hash12>": { "source": "<hash12>", "methods": ["<method key>"], "on": "2026-10-04" },
+ *     "block:<hash12>": { "source": "<hash12>", "methods": ["<method key>"], "on": "2026-10-04", "gate": 2 },
  *     "field:title":    { "source": "<hash12>", "methods": ["<method key>"], "on": "2026-10-04" },
  *     "page":           { "source": "<hash12>", "methods": ["<method key>"], "on": "2026-10-04" }
  *   }
@@ -52,10 +52,24 @@
  */
 
 import { tmMethodKey, lookupTM } from './tm.js';
+import { GATE_VERSION } from './validate.js';
 import { holdState, shortSourceHash } from './locale-state.js';
 import { contentRedoCommand } from './verify.js';
 import { translatableBlockSources } from './content-estimate.js';
 
+/**
+ * The lock value of a page written with something left in the source language
+ * (a block or front-matter field the gate refused): `pending:<source hash>`.
+ * It differs from the source hash, so the next sync processes the page again
+ * (the cache makes that free; a held unit is not re-sent), and it says the
+ * page is the tool's — a page with no lock entry is taken for a person's
+ * work and preserved. Before 2026-10-05 a visible '[EN] ' marker in the page
+ * did that job; no marker is written any more.
+ */
+export const PENDING_LOCK_PREFIX = 'pending:';
+export const pendingLockValue = (sourceHash) => `${PENDING_LOCK_PREFIX}${sourceHash}`;
+export const isPendingLock = (value) => typeof value === 'string' && value.startsWith(PENDING_LOCK_PREFIX);
+
 /** The content-lock key of one page × locale's refusals. */
 export function refusalRecordKey(manifestKey) {
   return `refused:${manifestKey}`;
@@ -85,7 +99,10 @@ export function readRefusals(manifest, manifestKey) {
   if (!rec || typeof rec !== 'object' || Array.isArray(rec)) return {};
   const out = {};
   for (const [id, r] of Object.entries(rec)) {
-    if (r && typeof r === 'object' && typeof r.source === 'string' && Array.isArray(r.methods)) out[id] = r;
+    // A refusal by an earlier gate lifts by itself (validate.js GATE_VERSION):
+    // what an over-strict check refused is asked again once it is fixed.
+    if (r && typeof r === 'object' && typeof r.source === 'string' && Array.isArray(r.methods)
+      && r.gate === GATE_VERSION) out[id] = r;
   }
   return out;
 }
@@ -140,7 +157,7 @@ export function nextRefusals(prior, { blockSources = [], pageSource = null, fiel
     if (!methods || methods.length === 0 || filled.has(unit)) continue;
     const src = shortSourceHash(source);
     const known = out[unit] && out[unit].source === src ? out[unit].methods : [];
-    out[unit] = { source: src, methods: [...new Set([...known, ...methods])], on };
+    out[unit] = { source: src, methods: [...new Set([...known, ...methods])], on, gate: GATE_VERSION };
   }
   return Object.keys(out).length > 0 ? out : null;
 }
@@ -161,21 +178,18 @@ export function storeRefusals(manifest, manifestKey, record) {
  * @param {string} p.pairKey
  * @param {object} p.pairConfig
  * @param {string[]} p.names - "paragraph 2", 'front matter "title"'
- * @param {boolean} [p.pageHeld] - A front-matter field (or the page body, in
- *   page mode) is held: the page is not written
+ * @param {boolean} [p.pageHeld] - The page body translated whole (page mode)
+ *   is held: the page is not written
  * @param {boolean} [p.handWritten] - The lane keeps a paragraph written by hand (contentDir)
- * @param {string} [p.fallbackPrefix]
  * @returns {string}
  */
-export function describeHeld({ file, code, pairKey, pairConfig, names, pageHeld = false, handWritten = false, fallbackPrefix = '[EN] ' }) {
+export function describeHeld({ file, code, pairKey, pairConfig, names, pageHeld = false, handWritten = false }) {
   const shown = names.slice(0, 5).join(', ') + (names.length > 5 ? `, +${names.length - 5} more` : '');
   const fb = pairConfig.fallback;
   const who = fb ? `${pairConfig.method}'s and its fallback's (${fb.method})` : `${pairConfig.method}'s`;
   const left = !pageHeld
-    ? `The '${fallbackPrefix.trim()}' text stays until they are filled.`
-    : names.includes(PAGE_NAME)
-      ? 'A page translated whole has no \'[EN]\' text to keep, so it is not written (and nothing of it is sent) until it is filled.'
-      : 'A front-matter field the gate refuses fails its page, so the page is not written (and nothing of it is sent) until it is filled.';
+    ? 'They stay in the source language (unmarked) until they are filled; the rest of the page is written.'
+    : 'A page translated whole is not written (and nothing of it is sent) until it is filled.';
   const other = fb
     ? 'another "fallback" method on the pair'
     : `a "fallback" method on the pair (it is asked for what ${pairConfig.method} refused)`;
@@ -222,12 +236,12 @@ export function describeNewHold({ file, pairKey, pairConfig, count, fallbackAske
  * @returns {string}
  */
 export function describeFallenBack({ file, pairKey, pairConfig, fellBack, newlyHeld, refusedBy = [] }) {
-  if (newlyHeld.length === 0) return 'Not cached, lock not advanced: the next sync retries just those block(s).';
+  if (newlyHeld.length === 0) return 'Not cached; the page is recorded as pending: the next sync retries just those block(s).';
   const retry = fellBack - newlyHeld.length;
   const fbKey = pairConfig.fallback ? tmMethodKey(pairConfig.fallback) : null;
   const fallbackAsked = !!fbKey && newlyHeld.some(i => !(refusedBy[i] || []).includes(fbKey));
   const n = newlyHeld.length;
-  return 'Not cached, lock not advanced. '
+  return 'Not cached; the page is recorded as pending. '
     + (retry > 0 ? `The next sync asks again for the ${retry} that got no usable answer. ` : '')
     + describeNewHold({
       file, pairKey, pairConfig, count: n, fallbackAsked,

package/lib/content-sync.js

@@ -89,7 +89,7 @@ import {
 } from './fallback.js';
 import {
   readRefusals, contentHolds, nextRefusals, storeRefusals, blockUnit, fieldUnit, describeHeld, describeNewHold,
-  describeFallenBack, previewHeld, PAGE_UNIT, PAGE_NAME,
+  describeFallenBack, previewHeld, PAGE_UNIT, PAGE_NAME, pendingLockValue, isPendingLock,
 } from './content-refusals.js';
 import { contentRedoCommand } from './verify.js';
 
@@ -364,7 +364,8 @@ async function runContentSync(options) {
 
         if (!retranslate && targetExists && !storedHash) {
           // No stored hash — check if this file was generated by a prior
-          // champollion run (contains [EN] fallback markers) or is a genuine
+          // champollion run (a legacy '[EN] ' fallback marker, written before
+          // 2026-10-05 — such pages are now recorded as pending:<hash>) or is a genuine
           // hand-translated file that should be preserved.
           //
           // BUG FIX: Previously, this always skipped hashless files.
@@ -455,11 +456,14 @@ async function runContentSync(options) {
           if (sourceCurrent) {
             output.info(`${code} — re-processing (--force-content; cached text is reused)`);
             result.retranslated = true;
+          } else if (storedHash === pendingLockValue(currentSourceHash)) {
+            output.info(`${code} — re-checking what was left in the source language last time (cached text is free)`);
+            result.retranslated = true;
           } else if (storedHash) {
             output.info(`${code} — source updated, re-translating`);
             result.retranslated = true;
           } else {
-            output.info(`${code} — replacing [EN] fallback`);
+            output.info(`${code} — replacing an older '[EN] ' fallback`);
           }
         }
 
@@ -532,7 +536,7 @@ async function runContentSync(options) {
         const holdPage = (names) => {
           refusal.held.push(...names);
           refusal.pageHeld = true;
-          output.warn(describeHeld({ file: relPath, code, pairKey, pairConfig, names, pageHeld: true, handWritten: true, fallbackPrefix }));
+          output.warn(describeHeld({ file: relPath, code, pairKey, pairConfig, names, pageHeld: true, handWritten: true }));
           output.event('file', { lane: 'content', file: relPath, locale: code, status: 'held-refused', held: names.length });
           result.heldBack = names.length;
           return result;
@@ -596,6 +600,9 @@ async function runContentSync(options) {
         // Each field is cached on its own source text, exactly like a
         // key-value sync key: a title edit re-pays only the title.
         const translatedFields = {};
+        // A field left in the source language (refused, or held from an earlier
+        // refusal): the page is written, its lock marked pending.
+        let fieldsLeftInSource = false;
         // Edits made by hand that this write keeps, and the ones whose
         // source text changed under them (re-translated; wording printed).
         const keptFieldNames = new Set();
@@ -648,7 +655,15 @@ async function runContentSync(options) {
           for (const f of Object.keys(translatedFields)) refusal.filled.add(fieldUnit(f));
           // Refused before: held back (the page with it), or the fallback's only.
           const heldFields = fieldsToSend.filter(f => holds.field(f, fieldsToTranslate[f]) === 'held');
-          if (heldFields.length > 0) return holdPage(heldFields.map(f => `front matter "${f}"`));
+          if (heldFields.length > 0) {
+            // Not sent again: the field keeps its source text and the page is
+            // written (its lock marked pending).
+            fieldsLeftInSource = true;
+            const names = heldFields.map(f => `front matter "${f}"`);
+            refusal.held.push(...names);
+            output.warn(describeHeld({ file: relPath, code, pairKey, pairConfig, names, handWritten: true }));
+            for (const f of heldFields) fieldsToSend.splice(fieldsToSend.indexOf(f), 1);
+          }
           const fallbackOnlyFields = new Set(fieldsToSend.filter(f => holds.field(f, fieldsToTranslate[f]) === 'fallback-only'));
 
           if (fieldsToSend.length > 0) {
@@ -668,9 +683,9 @@ async function runContentSync(options) {
               budget: fallbackBudget,
               sharedOutputs: sharedOutputsFor ? sharedOutputsFor(code) : null,
               label: `content:${relPath} front matter`,
-              translate: (keys, cfg) => translateBatch(
+              translate: (keys, cfg, extra = {}) => translateBatch(
                 keys, fieldsToTranslate, cfg,
-                { apiKey, cwd, model: cfg.model, batchSize: cfg.batchSize || 30 },
+                { apiKey, cwd, model: cfg.model, batchSize: cfg.batchSize || 30, ...extra },
               ),
               fallbackOnly: fallbackOnlyFields,
             });
@@ -681,29 +696,20 @@ async function runContentSync(options) {
               refusal.refused.push({ unit: fieldUnit(field), source: fieldsToTranslate[field], methods });
             }
             if (fm.hollowed.length > 0) {
-              const h = fm.hollowed[0];
-              output.raw(' [ERR]');
-              // A memorized sentence: asking the same model again returns it
-              // again — say so, and what does help (Round 6, school persona).
-              const advice = h.sharedOutput
-                ? (pairConfig.fallback
-                  ? `  ${pairConfig.method} can only answer this string with that sentence, and the fallback did not translate it either.\n`
-                    + `  Write "${h.field}" in ${targetRel} by hand (a hand-written field is kept), or try another fallback.`
-                  : `  ${pairConfig.method} can only answer this string with that sentence — asking it again returns the same.\n`
-                    + '  Add a "fallback" method to the pair (it is asked for what the primary\'s answer is refused for),\n'
-                    + `  or write "${h.field}" in ${targetRel} by hand (a hand-written field is kept).`)
-                : '  If this is a low-coverage target language,\n'
-                  + '  the model has no vocabulary for this string — fix the prompt or the pair.';
-              const err = new Error(
-                `Content sync for ${code}: front matter "${h.field}" — ${h.reason}.\n` +
-                `  source: ${JSON.stringify(fieldsToTranslate[h.field])}\n` +
-                `  got:    ${JSON.stringify(h.value)}\n` +
-                (h.fallbackReason ? `  the fallback (${pairConfig.fallback.method}) failed it too: ${h.fallbackReason}\n` : '') +
-                '  Nothing was written or cached.\n' + advice + '\n' +
-                `  ${describeNewHold({ file: relPath, pairKey, pairConfig, count: fm.hollowed.length })}`
-              );
-              err.heldNext = true;
-              throw err;
+              // Refused, and refused again when asked with the reason: the
+              // field keeps its source text; the page is still written.
+              fieldsLeftInSource = true;
+              for (const h of fm.hollowed) {
+                const advice = h.sharedOutput
+                  ? ` ${pairConfig.method} answers it only with a sentence it gave for other strings — `
+                    + `${pairConfig.fallback ? 'and the fallback did not translate it either' : 'add a "fallback" method to the pair'}, or write it in ${targetRel} by hand (kept).`
+                  : '';
+                output.warn(
+                  `${relPath} → ${code}: front matter "${h.field}" kept in the source language — ${h.reason}`
+                  + `${h.fallbackReason ? `; the fallback (${pairConfig.fallback.method}): ${h.fallbackReason}` : ''}.${advice}`
+                );
+              }
+              output.warn(describeNewHold({ file: relPath, pairKey, pairConfig, count: fm.hollowed.length }));
             }
             if (fm.noResults) {
               // Front matter translation failed — loud error, skip this file
@@ -722,8 +728,10 @@ async function runContentSync(options) {
             // the pair's method, so the page is held, as with no fallback.
             const unfilled = [...fallbackOnlyFields].filter(f => !(f in fm.translated));
             if (unfilled.length > 0) {
-              output.raw(' [HELD]');
-              return holdPage(unfilled.map(f => `front matter "${f}"`));
+              fieldsLeftInSource = true;
+              const names = unfilled.map(f => `front matter "${f}"`);
+              refusal.held.push(...names);
+              output.warn(describeHeld({ file: relPath, code, pairKey, pairConfig, names, handWritten: true }));
             }
             Object.assign(translatedFields, fm.translated);
             for (const f of Object.keys(fm.translated)) refusal.filled.add(fieldUnit(f));
@@ -870,7 +878,7 @@ async function runContentSync(options) {
               }));
 
               const missed = [];
-              const heldBlocks = []; // refused before: not sent, '[EN] ' kept
+              const heldBlocks = []; // refused before: not sent, the source text kept
               let position = 0; // index among translatable blocks (= translatableBlockSources order)
               for (const r of rendered) {
                 if (r.seg.type !== 'translatable') {
@@ -900,7 +908,7 @@ async function runContentSync(options) {
                 if (hold === 'held') {
                   // Refused before by this method (and its fallback): the
                   // honest last resort stays, nothing is sent or billed.
-                  r.out = restoreBlocks(fallbackPrefix + r.seg.text, blocks);
+                  r.out = r.source;
                   heldBlocks.push(r);
                   continue;
                 }
@@ -912,7 +920,7 @@ async function runContentSync(options) {
                 const names = heldBlocks.map(r => `paragraph ${r.pos + 1}`);
                 refusal.held.push(...names);
                 result.heldBack = (result.heldBack || 0) + names.length;
-                output.warn(describeHeld({ file: relPath, code, pairKey, pairConfig, names, handWritten: true, fallbackPrefix }));
+                output.warn(describeHeld({ file: relPath, code, pairKey, pairConfig, names, handWritten: true }));
               }
 
               if (missed.length > 0) {
@@ -926,8 +934,8 @@ async function runContentSync(options) {
                 // Self-repair ladder (translateBlockBatchResilient): full
                 // batch → one missing-segments-only retry → (with a fallback
                 // method: one batch through it for every block the primary
-                // dropped or damaged — lib/fallback.js) → honest
-                // '[EN] '-prefixed source for anything still missing. A
+                // dropped or damaged — lib/fallback.js) → the source text,
+                // unmarked, for anything still missing. A
                 // duplicate/unknown marker (untrustworthy mapping) or an
                 // empty first response still fails the file whole when no
                 // fallback rescues it.
@@ -937,7 +945,6 @@ async function runContentSync(options) {
                     missed,
                     blocks,
                     pairConfig,
-                    fallbackPrefix,
                     budget: fallbackBudget,
                     sharedOutputs: sharedOutputsFor ? sharedOutputsFor(code) : null,
                     label: `content:${relPath}`,
@@ -949,7 +956,6 @@ async function runContentSync(options) {
                         cwd,
                         pairConfig: cfg,
                       }),
-                      fallbackPrefix,
                     }),
                     fallbackOnly: new Set(missed.flatMap((r, i) => (r.fallbackOnly ? [i] : []))),
                   });
@@ -986,7 +992,7 @@ async function runContentSync(options) {
                 const refusedByGate = batchOutcome.refused || [];
                 if (refusedByGate.length > 0) {
                   output.warn(
-                    `Content sync body for ${code}: ${refusedByGate.length} block(s) of ${relPath} refused by the quality gate — `
+                    `Content sync body for ${code}: ${refusedByGate.length} block(s) of ${relPath} refused by the quality gate, also when asked again with the reason — `
                     + refusedByGate.slice(0, 3).map(r => `paragraph ${r.block}: ${r.reason}`).join('; ')
                     + `${refusedByGate.length > 3 ? '; …' : ''}`
                     + (pairConfig.fallback
@@ -997,7 +1003,7 @@ async function runContentSync(options) {
                 }
                 if (fellBack.length > 0) {
                   bodyUsedFallback = true;
-                  output.raw(' [EN]');
+                  output.raw(' [PARTIAL]');
                   // Refused as a memorized sentence (said just above) is not
                   // "missing from the response".
                   const refusedShared = (batchOutcome.sharedOutput || []).length + refusedByGate.length;
@@ -1010,8 +1016,7 @@ async function runContentSync(options) {
                         : 'missing from the model response after a retry';
                   output.warn(
                     `Content sync body for ${code}: ${fellBack.length} of ${missed.length} ` +
-                    `block(s) ${why} — written as ` +
-                    `'${fallbackPrefix}'-prefixed source. ` +
+                    `block(s) ${why} — left in the source language, unmarked (\`champollion status\` lists them). ` +
                     describeFallenBack({
                       file: relPath, pairKey, pairConfig, fellBack: fellBack.length, newlyHeld, refusedBy: batchOutcome.refusedBy,
                     })
@@ -1119,9 +1124,11 @@ async function runContentSync(options) {
         // A fallback body keeps its OLD manifest entry so the file re-fires
         // next sync — every good block is a TM hit, only the fallen-back
         // segment re-bills. Self-healing at bounded cost.
-        if (!bodyUsedFallback) {
-          updatedManifest[manifestKey] = currentSourceHash;
-        }
+        // Something left in the source language: `pending:<hash>` — the page
+        // is processed again next sync (cache-free; held units not re-sent)
+        // and stays the tool's, not taken for a person's file.
+        updatedManifest[manifestKey] = !bodyUsedFallback && !fieldsLeftInSource
+          ? currentSourceHash : pendingLockValue(currentSourceHash);
 
         return result;
       };
@@ -1466,10 +1473,11 @@ function countPendingContentTranslations(contentDir, sourceLocale, pairEntries,
  * persona). Local file reads only; never fails (a diagnostic).
  *
  *   translated  — the target exists and was made from the current source
- *                 (the content lock's hash matches), with no '[EN] ' block
+ *                 (the content lock's hash matches) and nothing left untranslated
  *   outOfDate   — the target was made from an older source text
- *   pending     — no target yet, or blocks written as the '[EN] ' last
- *                 resort (the next sync asks for them again)
+ *   pending     — no target yet, or parts the quality gate refused left in
+ *                 the source language (the lock says `pending:<hash>`, or a
+ *                 legacy '[EN] ' marker from before 2026-10-05 is in the file)
  *   unrecorded  — a target the lock has no record of (made by hand or by
  *                 another tool): sync keeps it as it is
  *
@@ -1477,7 +1485,7 @@ function countPendingContentTranslations(contentDir, sourceLocale, pairEntries,
  * @param {string} sourceLocale
  * @param {Array<[string, object]>} pairEntries
  * @param {string} cwd
- * @param {{ fallbackPrefix?: string }} [opts]
+ * @param {{ fallbackPrefix?: string }} [opts] - the legacy marker to look for
  * @returns {{ dir: string, files: number, locales: Object<string, { translated: number,
  *   outOfDate: string[], pending: string[], unrecorded: string[] }> }|null}
  */
@@ -1502,7 +1510,7 @@ function contentStatus(contentDir, sourceLocale, pairEntries, cwd, { fallbackPre
       let text = '';
       try { text = fs.readFileSync(targetPath, 'utf-8'); } catch { /* unreadable: by its record only */ }
       const stored = manifest[`${path.relative(contentDir, sourcePath)}:${code}`];
-      if (text.includes(fallbackPrefix)) state.pending.push(relPath);
+      if (isPendingLock(stored) || text.includes(fallbackPrefix)) state.pending.push(relPath);
       else if (!stored) state.unrecorded.push(relPath);
       else if (stored !== hash) state.outOfDate.push(relPath);
       else state.translated += 1;

package/lib/cost-report.js

@@ -40,7 +40,7 @@ import { diffLocale } from './diff.js';
 import { readLocaleFile } from './format.js';
 import { expectedForTarget, keysForNamespace, readLocaleFlat } from './locale-layout.js';
 import { mapSourceKeysToTarget } from './plurals.js';
-import { EST_CHARS_PER_KEY } from './config.js';
+import { contentKeyUnits } from './config.js';
 import { formatPerMillion } from './methods/openrouter-pricing.js';
 import { countPendingContentTranslations } from './content-sync.js';
 import { loadTM, lookupTM, partitionByTM, tmMethodKey, findModelSwitchStrandedEntries, reusableFromEarlierModels, carriedFromModel } from './tm.js';
@@ -382,9 +382,9 @@ export function abortForMaxCost(maxCost, estimatedCost, reason) {
 
 /**
  * Price per-pair content characters through each pair's own estimateCost().
- * Characters become EST_CHARS_PER_KEY-char key-equivalents (exact for
- * char-priced providers; conservative for token-priced LLMs, which pay the
- * per-key prompt overhead on every 25-char slice). A pair with 0 chars is a
+ * Characters become key-equivalents (lib/config.js contentKeyUnits): exact
+ * for char-priced providers; measured, still conservative, for token-priced
+ * LLMs, which pay the prompt once per page rather than per 25-char slice. A pair with 0 chars is a
  * KNOWN $0 and never consults estimateCost — an unknown-pricing null there
  * would wrongly abort a free run under --max-cost.
  *
@@ -405,7 +405,7 @@ export async function priceContentChars(charsByPair, pairEntries, estimateCost)
     const chars = charsByPair.get(pairConfig);
     if (!chars) continue;
     // eslint-disable-next-line no-await-in-loop — sequential is fine for cost queries (cached)
-    const estimate = await estimateCost(Math.ceil(chars / EST_CHARS_PER_KEY), pairConfig);
+    const estimate = await estimateCost(contentKeyUnits(chars, pairConfig), pairConfig);
     if (estimate.estimatedCost !== null) {
       cost += estimate.estimatedCost;
       if (estimate.rate) rates.push(estimate.rate);