A chapter comes back translated except for one paragraph. The rest reads fine in the target language; that one paragraph is flagged as failed, sitting in the middle of an otherwise finished chapter. The question is what to redo: the paragraph, or the chapter around it. The two choices look like a difference of size. They are a difference of kind, because the translation lives paragraph by paragraph, and each paragraph keeps its own verdict.
Each paragraph gets its own row, and no row expires on its own
For every paragraph, in every chapter, in every target language, there is one stored translation. The store holds the translation only, not the source text, and it holds no version number and no expiry date. A paragraph's translation stays valid until someone explicitly retranslates that paragraph or deletes it. Nothing in the background goes stale, and nothing is ever thrown away because time passed.
That changes what retry means. There is no chapter-level translation to invalidate. There are only rows, each either good or failed, and retry is a decision about which rows to replace.
Some failures are retried automatically, and some wait for a person
Not all failures are treated the same. A failure caused by the request itself — the network dropped, the model's output could not be parsed, the returned count did not match the request, the output length looked wrong — is retried automatically the next time the chapter is translated, once a short cooling period has passed. These are accidents of delivery, and sending again has a reasonable chance of working.
A failure caused by the content is handled differently. An empty translation, a translation that just copies the source, a translation with the wrong structure, or a translation in the wrong language is never retried on its own. Sending the same paragraph again would most likely produce the same wrong answer, so the system leaves the failed row in place and waits for a person to ask for it again. The failed row is still a row: it counts as covered, which matters for what "finished" means.
A finished chapter can still hold failed paragraphs
A chapter counts as finished when every translatable paragraph has a stored row. The verdict on those rows does not matter. A chapter of forty paragraphs, thirty-nine good and one failed, is finished. The reader is not waiting on a translation that never arrived; the reader is looking at a finished chapter with a flagged paragraph inside it.
This is why the retry choice matters. The system will not retry the content failures on its own, and it counts the chapter as finished anyway. If the reader wants that paragraph, someone has to ask for it specifically — or ask for the whole chapter again.
Redoing one paragraph touches exactly one row
The single-paragraph redo translates one paragraph and writes back one row. Everything around it is untouched: the good paragraphs keep their wording, and the failed paragraph's neighbours are not re-rolled as a side effect. The redo even borrows the previous paragraph's translation as context, so the new wording is shaped to fit the chapter that is already there.
If the redo fails again, it simply replaces one failed verdict with another, and it can be triggered again. Nothing else in the chapter is disturbed at any point. If I distrust one paragraph, I redo one paragraph, because the blast radius is exactly one row.
Redoing a whole chapter overwrites row by row, with no way to tell new from old
A whole-chapter redo does not delete the chapter's translations and start clean. It skips the cache, takes every translatable paragraph — good ones included — and retranslates them in batches, overwriting each row as its batch lands. The old wording of a paragraph disappears the moment its new translation is written. There is no history kept and no generation mark on a row, so nothing records which pass a good row came from. The chapter's only version marker is the time of its most recent write.
That makes an interrupted whole-chapter redo a peculiar object. If the redo stops halfway — the network breaks, the quota runs out — the chapter is half new and half old, and the two halves are indistinguishable. Both halves are rows with good verdicts. Nothing in the chapter says which paragraphs were re-done and which were left over from before.
An ordinary pass cannot unmix a half-new chapter
An ordinary pass skips every paragraph that already has a good row. It cannot tell a new good row from an old good row, so it leaves both alone. The mixed chapter is therefore stable: it will stay half new and half old until someone forces the whole chapter again, and that next force can itself be interrupted in the same way.
There is a middle choice that avoids the trap. Redoing only the failed paragraphs keeps every good row — new or old — and re-rolls just the failures. It cannot produce a mixed chapter, because it never touches a good row. The two whole-chapter options are mutually exclusive: either every good row is kept, or every row is up for replacement.
So the choice is about what gets discarded. One paragraph discards one verdict. Failed-only discards the failures. A whole-chapter redo discards everything, including good translations that can never be got back once their rows are overwritten — and if it stops halfway, the chapter keeps the mixture with no record of which half is which.
About the author
- Writing about ebook technology.
Comments
Join the discussionNo comments yet. Be the first to comment.