@@ -2591,7 +2591,11 @@ the file has it in any language, falling back to `items.other` and then
 `items` — the static paint and the live page by the same rules. A key's
 forms come from one language. Under `i18n.literals`, text with one number
 in it (`Text("{files} files")`) picks its form by that number:
-`"{files} files.one"`, `"{files} files.other"` … in each table. `format` and `ago` speak the locale too.
+`"{files} files.one"`, `"{files} files.other"` … in each table. Under
+literals a text is keyed by the names it splices (`{item?.name ?? ""}` is
+`{name}`); a `derived`, `state` or action-written value is looked up only
+when its name says it is words (`countText`, `emptyLabel`, `saidNote`);
+I05 warns of shown words that are neither. `format` and `ago` speak the locale too.
 `wf translations` is the table: what each locale lacks, what nothing names.
 
 RTL locales (automatic `dir="rtl"`, from the first paint when the default
@@ -3008,6 +3012,7 @@ And what the type checker finds:
 | `I01` | A literal `t("key")` that no locale's translations have, so the page shows the key |
 | `I02` | A message and its call that disagree: a value passed the message does not use, or a placeholder the call does not pass |
 | `I04` | `setLocale("xx")` naming a locale `i18n.locales` does not list |
+| `I05` | Under `i18n.literals`, shown words no table can translate: text splicing more than a name, or a value shown by a name that does not say it is words |
 | `V06` | A `$token` the resolved theme does not declare, so the property falls back to nothing |
 
 An endpoint a service does not have is `T06`, and an argument it does not
 
@@ -1689,6 +1689,15 @@ sees `nav.blog`. **Fix:** translate it, or remove it from the others.
 `setLocale("fr")` when `i18n.locales` is `["en", "ar"]`. **Fix:** add the
 locale and its file, or name one that exists.
 
+### I05 — Words a reader sees that are not translated
+
+Warning, under `"literals": true`. `Text("{plural(n, "file")} found")`
+splices a call, so no table can key it; `derived said = "{n} errors"`
+shown as `Text(said)` is not looked up, because only a value whose name
+says it is words (`saidText`, `errorsLabel`) is. A reader in Arabic sees
+both in English. **Fix:** splice names, `derived filesText = "{n} files"`
+then `Text("{filesText} found")`, and name what is words as words.
+
 ## Accessibility
 
 Warnings. What makes a page unusable with a screen reader, a keyboard or a voice.
 
@@ -1273,6 +1273,10 @@ page P(path: "/", title: "T", description: "D") {
 
         Markdown("`setLocale(\"fr\")` when `i18n.locales` is `[\"en\", \"ar\"]`. **Fix:** add the locale and its file, or name one that exists.")
 
+        Heading("I05 — Words a reader sees that are not translated", id: "i05-words-a-reader-sees-that-are-not-translated").h3
+
+        Markdown("Warning, under `\"literals\": true`. `Text(\"\{plural(n, \"file\")\} found\")` splices a call, so no table can key it; `derived said = \"\{n\} errors\"` shown as `Text(said)` is not looked up, because only a value whose name says it is words (`saidText`, `errorsLabel`) is. A reader in Arabic sees both in English. **Fix:** splice names, `derived filesText = \"\{n\} files\"` then `Text(\"\{filesText\} found\")`, and name what is words as words.")
+
         Heading("Accessibility", id: "accessibility").h2
 
         Markdown("Warnings. What makes a page unusable with a screen reader, a keyboard or a voice.")
 
@@ -532,6 +532,12 @@ pub static CODES: &[CodeInfo] = &[
         "A locale the project does not have",
         "`setLocale(\"xx\")` names a locale `i18n.locales` does not list.",
     ),
+    code(
+        "I05",
+        Warning,
+        "Words a reader sees that are not translated",
+        "Under `i18n.literals`, text that splices more than a name, or a value shown by a name that does not say it is words, is never looked up: every reader sees it as written.",
+    ),
     // ── A: accessibility ─────────────────────────────────────────────
     code(
         "A01",
 
@@ -66,10 +66,30 @@ fn name_of(e: &Expr) -> Option<String> {
             name_of(base)?;
             Some(n.clone())
         }
+        // A path with what it falls back to: `{item?.name ?? ""}`.
+        Expr::BinaryOp(left, crate::parser::ast::BinOp::NullCoalesce, right)
+            if matches!(**right, Expr::StringLiteral(_) | Expr::NumberLiteral(_)) =>
+        {
+            name_of(left)
+        }
         _ => None,
     }
 }
 
+/// Whether a piece of text is prose a reader reads, not a name or a code
+/// word: `Close`, `about `, `used in`, but not `rtl`, `main` or
+/// `webfluent.app.json`.
+fn prose(t: &str) -> bool {
+    let letters = t.chars().filter(|c| c.is_alphabetic()).count();
+    let capital = t
+        .trim_start()
+        .chars()
+        .next()
+        .is_some_and(|c| c.is_uppercase())
+        && t.chars().any(|c| c.is_lowercase());
+    letters >= 1 && (t.contains(char::is_whitespace) || capital || !t.is_ascii())
+}
+
 /// The key a string is looked up by, and what fills each placeholder:
 /// `"Problems"`, or `"{count} missing"` with `count`. None for a string
 /// that is not words, or that splices more than a plain path.
@@ -242,6 +262,15 @@ fn each_text(program: &mut Program, f: &mut dyn FnMut(&mut Expr, usize, Span)) {
                     }
                     each_field(&mut d.value, &mut |e| f(e, i, span));
                 }
+                // `wrote = "Wrote {n} changes."` in an action, to a value
+                // whose name says it is words.
+                StatementKind::Assignment(a) => {
+                    if target_name(&a.target).is_some_and(text_name) {
+                        each_shown(&mut a.value, &mut |e| f(e, i, span));
+                    }
+                    each_field(&mut a.value, &mut |e| f(e, i, span));
+                }
+                StatementKind::Return(Some(e)) => each_field(e, &mut |x| f(x, i, span)),
                 StatementKind::UIElement(ui) => {
                     for a in &mut ui.args {
                         match a {
@@ -271,6 +300,127 @@ fn each_text(program: &mut Program, f: &mut dyn FnMut(&mut Expr, usize, Span)) {
     }
 }
 
+/// The name an assignment writes: `wrote`, or `note` of `self.note`.
+fn target_name(e: &Expr) -> Option<&str> {
+    match e {
+        Expr::Identifier(n) => Some(n),
+        Expr::PropertyAccess(_, n) | Expr::OptionalProperty(_, n) => Some(n),
+        _ => None,
+    }
+}
+
+/// Whether `e` holds a string with words in it anywhere.
+fn holds_words(e: &Expr) -> bool {
+    let mut found = false;
+    e.clone().walk_mut(&mut |x| match x {
+        Expr::StringLiteral(t) if prose(t) => found = true,
+        Expr::InterpolatedString(parts) => {
+            found |= parts
+                .iter()
+                .any(|p| matches!(p, StringPart::Literal(t) if prose(t)))
+        }
+        _ => {}
+    });
+    found
+}
+
+/// Why words a reader sees are not translated.
+#[derive(Debug, Clone, PartialEq)]
+pub enum Untranslated {
+    /// Text that splices more than a plain path: `{plural(n, "file")}`.
+    Splices(String),
+    /// A value shown by its name, whose name does not say it is words, so
+    /// the strings it holds are not looked up: `said`.
+    Unnamed(String),
+}
+
+/// What a reader sees that no table translates, with where it is shown.
+pub fn untranslated(
+    program: &Program,
+    file_of: &dyn Fn(usize) -> String,
+) -> Vec<(String, Span, Untranslated)> {
+    // The values each body declares or writes words into, whose names do
+    // not say they are words; a store's by `Store.member` as well.
+    fn wordy(body: &[Statement], out: &mut std::collections::BTreeSet<String>) {
+        for s in body {
+            match &s.kind {
+                StatementKind::State(d) if !text_name(&d.name) && holds_words(&d.value) => {
+                    out.insert(d.name.clone());
+                }
+                StatementKind::Derived(d) if !text_name(&d.name) && holds_words(&d.value) => {
+                    out.insert(d.name.clone());
+                }
+                StatementKind::Assignment(a) => {
+                    if let Some(n) = target_name(&a.target) {
+                        if !text_name(n) && holds_words(&a.value) {
+                            out.insert(n.to_string());
+                        }
+                    }
+                }
+                _ => {}
+            }
+            let mut kind = s.kind.clone();
+            for b in kind.bodies_mut() {
+                wordy(b, out);
+            }
+        }
+    }
+    let mut copy = program.clone();
+    let mut by_body: std::collections::HashMap<usize, std::collections::BTreeSet<String>> =
+        std::collections::HashMap::new();
+    let mut stores = std::collections::BTreeSet::new();
+    for (i, body) in bodies(&mut copy) {
+        let mut names = std::collections::BTreeSet::new();
+        wordy(body, &mut names);
+        by_body.insert(i, names);
+    }
+    for (i, d) in program.declarations.iter().enumerate() {
+        if let Declaration::Store(st) = d {
+            for n in by_body.get(&i).into_iter().flatten() {
+                stores.insert(format!("{}.{n}", st.name));
+            }
+        }
+    }
+    let unnamed = |x: &Expr, i: usize| -> Option<String> {
+        match x {
+            Expr::Identifier(n) if by_body.get(&i).is_some_and(|s| s.contains(n)) => {
+                Some(n.clone())
+            }
+            Expr::PropertyAccess(base, m) | Expr::OptionalProperty(base, m) => match &**base {
+                Expr::Identifier(st) if stores.contains(&format!("{st}.{m}")) => {
+                    Some(format!("{st}.{m}"))
+                }
+                _ => None,
+            },
+            _ => None,
+        }
+    };
+    let mut out = Vec::new();
+    each_text(&mut copy, &mut |e, i, span| {
+        let why = match e {
+            Expr::InterpolatedString(parts) => {
+                let words = parts
+                    .iter()
+                    .any(|p| matches!(p, StringPart::Literal(t) if prose(t)));
+                parts.iter().find_map(|p| match p {
+                    StringPart::Expression(x) if words && name_of(x).is_none() => {
+                        Some(Untranslated::Splices(crate::print::expr(x)))
+                    }
+                    StringPart::Expression(x) => unnamed(x, i).map(Untranslated::Unnamed),
+                    _ => None,
+                })
+            }
+            other => unnamed(other, i).map(Untranslated::Unnamed),
+        };
+        if let Some(why) = why {
+            out.push((file_of(i), span, why));
+        }
+    });
+    out.sort_by(|a, b| (&a.0, a.1.line, a.1.col).cmp(&(&b.0, b.1.line, b.1.col)));
+    out.dedup();
+    out
+}
+
 /// Every string a reader sees, as the `t()` call it stands for.
 pub fn translate(program: &mut Program) {
     each_text(program, &mut |e, _, _| {
@@ -380,6 +530,56 @@ mod tests {
         assert_eq!(k, "{name} and {name2}");
     }
 
+    #[test]
+    fn a_path_with_its_fallback_is_named_by_the_path() {
+        let (key, args) = key_of(&expr("\"Delete {item?.name ?? \\\"\\\"}?\"")).unwrap();
+        assert_eq!(key, "Delete {name}?");
+        assert_eq!(crate::print::expr(&args[0].1), "item?.name ?? \"\"");
+        assert!(
+            key_of(&expr("\"{a ?? b} left\"")).is_none(),
+            "a fallback that is not a value"
+        );
+    }
+
+    #[test]
+    fn words_written_in_an_action_to_a_value_named_as_words_are_looked_up() {
+        let mut p = page(
+            "store S {\n    state wroteNote = \"\"\n    state kind = \"\"\n    action save(n: Number) {\n        wroteNote = \"Wrote {n} changes.\"\n        kind = \"Kept as it is\"\n    }\n}\n",
+        );
+        translate(&mut p);
+        let Declaration::Store(st) = &p.declarations[0] else {
+            panic!()
+        };
+        let out = format!("{:?}", st.body);
+        assert!(out.contains("Wrote {n} changes."), "{out}");
+        assert!(
+            out.contains("FunctionCall(\"t\", [StringLiteral(\"Wrote {n} changes.\")"),
+            "{out}"
+        );
+        assert!(
+            !out.contains("FunctionCall(\"t\", [StringLiteral(\"Kept as it is\")"),
+            "{out}"
+        );
+    }
+
+    #[test]
+    fn words_no_table_can_translate_are_found_where_they_are_shown() {
+        let p = page(
+            "page P(path: \"/\") {\n    state n = 2\n    derived said = \"{n} errors\"\n    derived saidText = \"{n} errors\"\n    derived dir = if n > 1 { \"rtl\" } else { \"ltr\" }\n    Text(said)\n    Text(saidText)\n    Text(dir)\n    Text(\"Found {n + 1} more\")\n    Text(\"{n + 1}:{n}\")\n}\n",
+        );
+        let found: Vec<(u32, Untranslated)> = untranslated(&p, &|_| "src/pages/p.wf".into())
+            .into_iter()
+            .map(|(_, span, why)| (span.line, why))
+            .collect();
+        assert_eq!(
+            found,
+            [
+                (6, Untranslated::Unnamed("said".into())),
+                (9, Untranslated::Splices("n + 1".into())),
+            ]
+        );
+    }
+
     #[test]
     fn the_branches_a_text_chooses_between_are_each_looked_up() {
         let mut p = page(
 
@@ -458,6 +458,29 @@ pub fn translations(
             );
         }
     }
+    // I05: words a reader sees that no table can translate.
+    if config.literals {
+        use crate::i18n::literals::Untranslated;
+        for (file, span, why) in crate::i18n::literals::untranslated(program, file_of) {
+            let (message, hint) = match why {
+                Untranslated::Splices(x) => (
+                    format!("this text is not translated: it splices `{x}`, which is more than a name"),
+                    "Give it a name — a `derived` — and splice that name; the table keys a text by the names it splices".to_string(),
+                ),
+                Untranslated::Unnamed(n) => {
+                    let last = n.rsplit('.').next().unwrap_or(&n).to_string();
+                    (
+                        format!("`{n}` is shown, but its words are not translated: only a value whose name says it is words is looked up"),
+                        format!("Rename it `{last}Text`, or end its name in Label, Title, Word, Note, Message …"),
+                    )
+                }
+            };
+            out.push(
+                Diagnostic::coded("I05", message, &file, span.line as usize, span.col as usize)
+                    .with_hint(hint),
+            );
+        }
+    }
     out
 }
 
 
@@ -1173,7 +1173,7 @@ fn every_diagnostic_example_draws_its_code() {
 /// program — its config, its scripts, its output mode — can show.
 const EXAMPLE_EXEMPT: &[&str] = &[
     "E003", "E005", "E108", "E109", "E110", "E111", "E112", "E115", "E901", "E902", "D05", "D01",
-    "D04", "I01", "I02", "I03", "I04", "A13", "V02",
+    "D04", "I01", "I02", "I03", "I04", "I05", "A13", "V02",
 ];
 
 /// The anchor a heading gets on the site and on GitHub, as the generator