agent-quality-kit 0.8.0 → 0.10.0

package/tool/i18n/en.mjs

@@ -7,6 +7,8 @@ import { enDocs } from "./en-docs.mjs";
 
 import { templates } from "./templates-en.mjs";
 
+import { enGates } from "./en-gates.mjs";
+
 export const en = {
   learn: {
     title: "Said out loud, never written down",
@@ -28,6 +30,7 @@ export const en = {
     init: "lay the rules and guides into the current project",
     initForce: "overwrite files that already exist",
     start: "no code yet: day-zero guards and the order of work",
+    probe: "what the declared checks cannot see: plant a defect into files history calls hot",
     prove: "prove the gates catch a defect: each against its own red and green sample",
     doctor: "check what is laid out and what is missing",
     doctorRun: "and also run the declared gates",
@@ -44,6 +47,7 @@ export const en = {
     contextInstall: "the same in full — the map and the rulebook — installed as a hook",
     report: "the mandatory report form: what is in place, what is not, what was not read; --since <ref> adds what proves the diff",
     badge: "a level badge for your README — and a check that it does not lie",
+    version: "the banner and the version number — same as --version and -v",
     noInstall: "Without installing:  npx agent-quality-kit init",
     language: "Output language: AQK_LANG=ru (or en), otherwise your system locale",
   },
@@ -87,6 +91,16 @@ export const en = {
     hasThings: "has",
     install: (cmd) => `install: ${cmd}`,
     notApplicable: (n) => `Not applicable to this repository (${n}):`,
+    noBrowserServer:
+      "this project has a UI, and the agent has no browser: it cannot look at its own change\n  and judges the work by what compiled. Those are different claims.",
+    noBrowserServerHow: (l) => `add an MCP server — works with any agent: ${l}`,
+    coveredBy: (n) => `held by another arbiter: ${n} — the portable entry is not needed`,
+    coveredByGate: (g) => `held by "${g}", declared in the manifest`,
+    coversUnknown: (l) => `covers names a gate absent from gates: ${l} — those entries are held by nothing`,
+    coversUnproven: (e, g, codes) =>
+      `claim unverified: "${e}" is declared held by gate "${g}", but neither its command nor the\n  linter config names rules ${codes} — the entry may be held by nothing`,
+    coversUnprovenHow: (cmd) => `settle it: add those rules to the linter, or install the entry — ${cmd}`,
+    totalCovered: (n) => `held by another arbiter ${n}`,
     total: "Total:",
     totalHeld: (n) => `held by a machine ${n}`,
     totalTodo: (n) => `applicable but not installed ${n}`,
@@ -96,6 +110,7 @@ export const en = {
     sinceBadRef: (ref) => `cannot compare against "${ref}": no such ref, or this is not a git repository`,
     notScopable: "output carries no paths — cannot be narrowed by diff, left red",
     outsideDiff: (n) => `findings exist, but outside the diff (${n})`,
+    advisoryQuiet: "(advisory — cannot fail the run)",
     advisoryMark: "advisory — shown, the run was not failed",
     advisorySummary: (names) =>
       `advisory and red: ${names.join(", ")}. These are switched-off checks: ` +
@@ -110,7 +125,15 @@ export const en = {
     manifestUnknown: (keys) =>
       `The manifest has fields the standard does not know: ${keys.join(", ")}. Looks like a typo — ` +
       `such a field is silently read as absent, and the verdict comes out wrong.`,
+    manifestUnparsed: (n, t) => `manifest line ${n} was not parsed and HAS NO EFFECT: ${t}`,
+    manifestUnparsedWhy:
+      "field and gate names use latin letters, digits, dash and underscore. What is declared here\n  does not run at all — while looking as if it does.",
     manifestKnown: (keys) => `Manifest fields: ${keys.join(", ")}`,
+    runVerdictOk: "Everything declared is green.",
+    runVerdictFail: (why) => `The run is red: ${why}.`,
+    whyMissing: "files from the header are missing",
+    whyLevel: "the level was not reached",
+    whyGates: (n, names) => `${n} red gate(s)${names ? ` (${names})` : ""}`,
     thresholdPass: (min) => `Threshold AQK-${min} passed.`,
     thresholdFail: (min, now) => `Threshold AQK-${min} NOT passed: currently AQK-${now}.`,
     thresholdGateFail: (min, now, names) =>
@@ -164,6 +187,8 @@ export const en = {
       has_agent_config: ["the agent was never configured here", "agent settings exist"],
       has_agent_entry: ["no entry point for an agent here", "an entry point for an agent exists"],
       has_ui: ["no stylesheets or UI components in sight", "a UI exists: stylesheets or components"],
+      has_mcp: ["no MCP tools are wired up for the agent here", "MCP servers are declared"],
+      has_api_spec: ["no API specification in sight", "an API specification exists"],
     },
   },
 
@@ -189,283 +214,5 @@ export const en = {
     alreadyDeclared: "already declared",
   },
 
-  add: {
-    noSuchGate: (slug, cmd) => `No such gate: ${slug}\nThe applicable ones — ${cmd}`,
-    toolMissing: (slug, missing) =>
-      `Entry ${slug} needs ${missing.join(" and ")}, which is not on this machine.\n  fix: install ${missing.join(" and ")} and try again — this entry delegates to a ready-made tool by design and has no check of its own.`,
-    noRecipe: (slug, stack, missing) =>
-      `Entry ${slug} has no command for ${stack} and no portable one.` +
-      (Array.isArray(missing) && missing.length
-        ? `\n  fix: install ${missing.join(" or ")} and try again — this entry delegates to a ready-made tool by design and has no check of its own.`
-        : `\n  fix: add a recipe for your stack to this entry's gate.yml, or pick another entry.`),
-    thisStack: "this stack",
-    needName: (cmd, doctor) => `Name the gate: ${cmd}. The list — ${doctor}`,
-    noManifest: (cmd) => `No .aqk.yml — run ${cmd} first`,
-    notApplicable: (why) => `This gate does not apply to the repository: ${why}`,
-    installAnyway: "Installing anyway — your call, but it has nothing to guard here.",
-    copied: (n) => `${n} files: the check and its samples`,
-    declared: (cmd) => `gate declared: ${cmd}`,
-    notDeclared: (why, slug, cmd) => `untouched (${why}). Add it yourself: ${slug}: "${cmd}"`,
-    nextTitle: "Next:",
-    next1: "Check that it goes red and stays quiet where it should:",
-    expectFail: "→ a failure is expected",
-    expectSilence: "→ silence is expected",
-    next2: "Put the command into your commit hook and your pipeline.",
-    next2Why: "A gate nobody runs is not a gate.",
-    next3: (cmd) => `Run everything declared: ${cmd}`,
-  },
-
-  gnew: {
-    needName: (cmd) => `Name it: ${cmd}`,
-    badName: (slug) => `The name "${slug}" will not do: lowercase latin with dashes, e.g. secrets-not-in-code.\nThe name is read in other people's projects — it is part of a shared vocabulary.`,
-    looksExisting: (slug) => `Looks like this already exists: ${slug}`,
-    recipeNotGate: "A recipe for another stack is a line in the recipes of an existing entry.",
-    forceHint: (cmd) => `Create a new one anyway: ${cmd}`,
-    exists: (path) => `${path} already exists.`,
-    nextTitle: "Next, in order:",
-    n1: "Check whether an off-the-shelf rule exists",
-    n1Where: "in ruff, eslint, semgrep.",
-    n1Why: "Off-the-shelf is more precise, better documented and maintained without you. Your own check is the fallback.",
-    n2: "Add the samples.",
-    n2Red: "— code the check must fire on.",
-    n2Green: "— the same code, done right.",
-    n2Why: "The green one matters more: it catches a check that goes red on correct code.",
-    n3: "Write the check",
-    n3Where: "in check.sh. The failure text must say what exactly to do.",
-    n4: "Fill in gate.yml:",
-    n4What: "the intent, the trigger, the failure it proved itself on.",
-    n5: "Run it:",
-    n5Why: "The arbiter must go red on red/ and stay quiet on green/. It did not — it is not an entry.",
-  },
-
-  ratchet: {
-    needName: (cmd) => `Name the gate: ${cmd}. It must already be declared in .aqk.yml`,
-    noManifest: (cmd) => `No .aqk.yml — run ${cmd} first`,
-    notDeclared: (slug, cmd) => `Gate "${slug}" is not declared in .aqk.yml. First: ${cmd}`,
-    already: (slug) => `Gate "${slug}" already has a ratchet.`,
-    notRunnable: (slug, cmd) =>
-      `Gate "${slug}" does not run: ${cmd}\n` +
-      `You cannot capture debt from a guard that does not exist — its own error messages\n` +
-      `would land in the registry and become a permission. Fix the command first.`,
-    registryHead: (slug, stamp) =>
-      `# Debt registry: ${slug}\n` +
-      `# Captured ${stamp}. This list may ONLY get shorter.\n` +
-      `# A new violation turns the gate red; a fixed one is struck out automatically.\n` +
-      `#\n` +
-      `# Debt with no goal and no deadline never ends. The goal is how many violations count as\n` +
-      `# paid off; on reaching it the ratchet tells you to remove the wrapper. The deadline is\n` +
-      `# optional, but if set, debt still open past that date turns the gate red — a deadline\n` +
-      `# without a consequence is not a deadline.\n` +
-      `# aqk-goal: 0\n` +
-      `# aqk-deadline:\n`,
-    recorded: (n) => `${n} violations recorded as debt`,
-    libCopied: "wrapper copied into the project",
-    wrapped: "command wrapped in the ratchet",
-    changesTitle: "What this changes:",
-    fromToday: "from the day it is installed",
-    changes1: (fromToday) => `The rule applies ${fromToday}. The old code stays untouched, but a new`,
-    changes2: "violation of the same class will not get through.",
-    test1: 'The test for a ratchet rather than an advisor: "can new code add a violation',
-    test2: 'and still pass?" If it can, there is no gate.',
-    run: (cmd) => `Run it: ${cmd}`,
-  },
-
-  find: {
-    needQuery: (cmd) => `Describe the intent in words: ${cmd}`,
-    example: 'find "debug printing reaches production"',
-    exists: "This already exists — no new entry needed:",
-    match: (pct) => `${pct}% match`,
-    recipes: (langs) => `recipes: ${langs}portable`,
-    existsWhy1: "If you have a recipe for another stack, that is a line in the recipes of the",
-    existsWhy2: "existing entry, not a new gate. One intent, many possible executors.",
-    near: "No exact match, but these are close:",
-    nearWhy: "Read their README. If the intent is the same — extend it, do not start a new one.",
-    none: "No such intent in the catalogue.",
-    journal: "The journal has a bruise on this topic:",
-    journalWhy: "A recorded bruise means the proof for a new entry already exists.",
-    howTitle: "How to add your own gate:",
-    how1: "Name the failure.",
-    how1What: "What concrete defect it caught in a live project, and what that cost.",
-    how1Why: '"It is a good practice" is not accepted: that is how a catalogue collects hundreds of entries and dies.',
-    how2: "Create the folder",
-    how2What: "— gate.yml, red/, green/, README.md.",
-    how2Why: "The full entry format is in kit/gates/README.md",
-    how3: "Check it by machine:",
-    how3Why: "The arbiter must go red on red/ and stay quiet on green/. It did not — it is not an entry.",
-    how4: "Send it as a change",
-    how4What: "to the kit repository.",
-  },
-
-  why: {
-    needQuery: (cmd) => `Describe what slipped through: ${cmd}`,
-    example: 'why "a file grew to nine thousand lines"',
-    ciAtOnce: "all at once: doctor --run",
-    ciOwnStep: "as its own step",
-    unsure: "No confident match. These entries look close:",
-    unsureByName: (cmd) => `Name the entry directly: ${cmd}`,
-    unsureNone: (cmd) => `None of them fits — then there was no guard: ${cmd}`,
-    decideTitle: "The rest is your call:",
-    decideQ: "is this specific to you, or a general case?",
-    decideWhy: "General goes into the catalogue and reaches everyone. Specific stays with you.",
-    decideNote: (cmd) => `Either way, the lesson goes into the shared journal: ${cmd}`,
-    fix: "Fix it like this:",
-    noGuard: "There was no guard.",
-    noGuardWhy: "No entry in the catalogue carries this intent.",
-    noGuardFix: (cmd) => `create an entry — ${cmd}`,
-    noGuardHint: "Take the red sample straight from this failure: it already happened, nothing to invent.",
-    closest: (slug, pct) => `Closest catalogue entry: ${slug}  ${pct}% match`,
-    notInstalled: "The guard exists in the catalogue but is not installed in this project.",
-    notInstalledHint1: "It will go red on old code — that is normal: the old is covered by a ratchet,",
-    notInstalledHint2: (cmd) => `the new is caught from day one. ${cmd}`,
-    declaredAs: (cmd) => `Declared as: ${cmd}`,
-    notRunning: "The guard is declared but does not run.",
-    notRunningWhy: "The worst case: silence reads as success.",
-    notRunningFix: "the path or the program in the command does not exist — check them.",
-    notRunningHint: 'A missing signal is indistinguishable from success, so this is not "a small config detail".',
-    bypassed: "The guard exists and catches this failure — so it was bypassed.",
-    noCiFix: "there is no pipeline. A check only a human runs",
-    noCiHint: 'works right up until the first "forgot".',
-    notInCiFix: "a pipeline exists, but this gate does not run in it.",
-    notInCiHint: (cmd) => `The cheapest way is one step: ${cmd} — it runs everything declared.`,
-    inCiFix: (how) => `the pipeline does run it (${how}) — so a red run`,
-    inCiHint1: "was skipped or overridden. Move the rule out of prose and into mechanics:",
-    inCiHint2: "a blocking step, not an optional one; no merging while red.",
-    blind: "The guard exists, is installed and runs — but does not see this failure.",
-    blindFix: (dir) => `put a piece of the broken code into ${dir}`,
-    blindHint1: "and drive the check to red on it. The order is the reverse of the habit: the sample",
-    blindHint2: "first, the fix second — otherwise it is unclear what exactly got fixed.",
-    blindCheck: "Verify after the fix: bash tool/selfcheck/gates.sh",
-  },
-
-  init: {
-    noDocs: (dir) => `Guides not found: ${dir}\nLooks like the package is not fully installed.`,
-    docsRu:
-      "the guides in .aqk/docs/ are in Russian — a deliberate decision, not a broken install.\n  The rules in .aqk/rules/ are in English; the guides are prose an agent may ignore anyway,\n  and what a machine holds lives in .aqk.yml and the gates. Translation waits for someone who needs it.",
-    created: (n) => `created (${n}):`,
-    andMore: (n) => `… and ${n} more`,
-    kept: (n) => `already there, left untouched (${n}):`,
-    overwrite: (cmd) => `overwrite: ${cmd}`,
-    nextTitle: "What to do next, in order:",
-    n1a: "Open",
-    n1b: 'and fill in the "Commands" section. A command you cannot',
-    n1c: "copy and run is not a command, it is a wish.",
-    n2a: "Read",
-    n2b: "— it is the minimum a project needs,",
-    n2c: "independent of language. Go through it top to bottom and mark what is missing.",
-    n3a: "Fill in",
-    n3b: "— gates, samples, journal. Your AQK level",
-    n3c: (cmd) => `is computed from it: ${cmd}.`,
-    n4a: "Climb the levels",
-    n4b: "one at a time",
-    n4c: ". A gate guards an artefact that exists:",
-    n4d: "a check for code that is not written yet is a dead rule.",
-    burned: (cmd) => `Got burned by something — write it down: ${cmd}`,
-    hookHint: (cmd) => `Claude Code: ${cmd} — the project state will reach the agent's context\n  by itself, before its first action. Other agents have no hook, and that is not an omission.`,
-  },
-
-  feedback: {
-    title: "If this was useful:",
-    star: (url) => `Star it — ${url}`,
-    issue: "Found a bug or it did not fit — open an issue; both are the most useful feedback there is.",
-    once: "This message is shown once: it will not appear again on this machine.",
-  },
-
-  note: {
-    journalTitle: "Bruise journal",
-    needTitle: (cmd) => `A title is required: ${cmd}`,
-    noJournal: (url) => `No journal clone found.\nDo this once:\n  git clone ${url}.git ~/projects/aqk\nor point at it: export AQK_HOME=/path/to/aqk`,
-    journalMissing: (path) => `Journal not found: ${path}`,
-    emptyBody: `The entry body is empty. Pass it on standard input, for example:\n\n  aqk note "title" <<'EOF'\n  **What happened.** ...\n  **What it cost.** ...\n  **Conclusion.** 🔧 ...\n  EOF`,
-    noOutcome:
-      "The entry carries no decision mark. A lesson without a conclusion is a story, not a lesson.\n" +
-      "Add one of the three:\n" +
-      "  ✅ **Became a gate:** <catalogue entry name>\n" +
-      "  🔧 **Became a change to the tooling:** <what exactly changed>\n" +
-      "  👤 **Will not become a gate:** <why>",
-    unknownProject: "unknown",
-    projectField: "Project",
-    pushed: (title) => `Recorded and pushed: ${title}`,
-    localOnly: (cmd) => `Recorded locally, the push failed. Push it: ${cmd}`,
-  },
-
-  blob: {
-    noDocs: (dir) => `Guides not found: ${dir}`,
-    header: (stamp) =>
-      `<!-- ASSEMBLED BY aqk blob ${stamp} from kit/docs. Do not edit by hand:\n` +
-      `     the next assembly overwrites it. The source is the separate files. -->\n\n` +
-      `# AQK — the guides in one file\n`,
-    source: (path) => `source: ${path}`,
-    done: (n, kb) => `GOD_AI.md — ${n} files, ${kb} KB`,
-    rebuilt: "Reassembled by every run. Edit the originals in kit/docs.",
-  },
-
-  start: {
-    noRecipeHere: "needs a tool that is not on this machine",
-    initFailed: (cmd) => `Could not lay out the kit. Start with ${cmd}`,
-    tooManyFiles: (n) => `This repository already has ${n} code files — that is a different scenario.`,
-    useDoctor: (cmd) => `${cmd} will inspect what is here and split the entries into three lists:`,
-    threeLists: "held by a machine · applicable but not installed · not applicable, and why.",
-    anyway: (cmd) => `Install the day-zero guards anyway: ${cmd}`,
-    expectRed: "Expect red: a guard installed onto living code goes red across all of it.",
-    expectRedFix: (cmd) => `That is cured by a ratchet — ${cmd} — not by switching it off.`,
-    installed: (n) => `Day-zero guards installed: ${n}`,
-    noDebt1: "There is no debt: on an empty project they have nothing to let through. The same guard,",
-    noDebt2: "installed six months later, would go red on all the old code — and be switched off.",
-    allDeclared: "Every applicable entry is already declared.",
-    notYet: "Not applicable yet:",
-    notYetWhy: "Once the sign appears, the entry shows up on its own.",
-    orderTitle: "The order people actually do this in:",
-    o1: "The task, in words.",
-    o1What: "What, and for whom, without a single technical term.",
-    o1Why: "Until the task is described in words, any architecture protects who knows what.",
-    o2: "Constraints.",
-    o2What: "Deadlines, money, load, what you are not allowed to use.",
-    o2Why: "Constraints pick the solution far more often than taste does: without them, taste picks.",
-    o3: "Sizing.",
-    o3What: "How much data, how many requests, how many people — in numbers, at least an order of magnitude.",
-    o3Why: 'A number separates "we need a queue" from "a table is enough". Without it, people argue in words.',
-    o4: "Architecture.",
-    o4What: "And only now — out of the first three, not before them.",
-    softNote1: "The program does not check this order: it lives in .aqk/docs/, and an agent can",
-    softNote2: "ignore it. The machine holds something else — the guards above. The difference between",
-    softNote3: "soft and hard is exactly this: text is asked for, a command is executed.",
-    next: "Next:",
-    nextWhy: "— run everything that is declared",
-  },
-
-
-  prove: {
-    title: "aqk prove — proving the gates",
-    running: "proving the gates against their samples…",
-    proven: (n) => `proven: ${n}`,
-    broken: (n) => `do not catch: ${n}`,
-    unprovable: (n) => `nothing to prove with: ${n}`,
-    okRed: "red on the red sample, silent on the green one",
-    redPassed: "stayed silent on the RED sample — the gate does not catch the defect",
-    greenFailed: "went red on the GREEN sample — the gate complains about working code",
-    empty: "the command is empty — a declaration without a command protects nothing",
-    noSamples: "no samples — nothing to prove with",
-    noTarget: "no place to substitute the sample directory — the command was written by hand",
-    otherRecipe: (lang) => `the samples are written for the "${lang}" recipe, another one is installed — nothing to prove with`,
-    noGates: "no gates declared — nothing to prove",
-    noSamplesDir: "the samples field in .aqk.yml is empty — nowhere to look for samples",
-    nothingProven:
-      "not a single gate is proven. A level above AQK-1 would mean trust in the author, not a fact:\n  a project whose gate is `true` would pass it exactly like a project with real protection.",
-    fix: (cmd) => `fix: install a catalogue entry together with its samples — ${cmd}`,
-    heading: "Proving the gates",
-  },
-  badge: {
-    noManifest: (cmd) => `No .aqk.yml — there is no level yet. Start with ${cmd}`,
-    notReached: (cmd) => `AQK-0 is not reached — there is nothing to put on a badge. What is missing: ${cmd}`,
-    redGates: (n, names) =>
-      `Red gates: ${n} (${names}). A badge issued over a red gate is the author's claim, not a machine's fact.`,
-    hint: (n) => `Proven by a run. Green gates: ${n}. Paste the line above into your README.`,
-    keepTrue: (cmd) => `To keep the badge from turning into a lie, put this in your pipeline: ${cmd}`,
-    checkMissing: (places) => `No AQK badge in any of: ${places}. This is the line to paste:`,
-    checkMismatch: (where, level) => `The badge lies: ${where}, while the run says AQK-${level}. Replace it with:`,
-    checkOk: (level, where) => `Badge matches the run: AQK-${level} — ${where}`,
-  },
-
-
-
+  ...enGates,
 };

package/tool/i18n/index.mjs

@@ -11,23 +11,56 @@
 // хуже и расходятся молча. Каталоги лежат отдельно, и модульная проверка сверяет, что в них
 // одни и те же ключи: «поддерживаем два языка» — утверждение, которое обязана держать машина.
 
+import { readFileSync } from "node:fs";
+import { join } from "node:path";
 import { ru } from "./ru.mjs";
 import { en } from "./en.mjs";
 
 // Порядок: явная переменная окружения → системная локаль → английский. Английский последним
 // потому, что незнакомый язык интерфейса — это препятствие, а незнакомый английский в 2026-м
 // препятствие меньшее, чем незнакомая кириллица.
-function pickLang(env = process.env) {
+// Порядок: переменная окружения → ПОЛЕ МАНИФЕСТА → системная локаль → английский.
+//
+// Поле манифеста добавлено 2026-09-08 по просьбе первого чужого пользователя: «язык берётся из
+// LC_ALL/LANG, а на Windows их просто нет: русский проект получает английский вывод. AQK_LANG=ru
+// чинит, но у следующего человека будет своё». Он прав: язык репозитория — свойство репозитория,
+// а локаль — свойство машины, на которой его сегодня открыли.
+//
+// Переменная окружения оставлена ВЫШЕ манифеста намеренно: человек, набравший AQK_LANG=en
+// руками, хочет английский именно сейчас, и спорить с ним манифестом значит отнять у него
+// последнее средство. Манифест выше локали — он про проект, локаль про машину.
+function pickLang(env = process.env, man = null) {
   const forced = String(env.AQK_LANG || "").toLowerCase();
   if (forced.startsWith("ru")) return "ru";
   if (forced.startsWith("en")) return "en";
+  const declared = String(man?.lang || "").toLowerCase();
+  if (declared.startsWith("ru")) return "ru";
+  if (declared.startsWith("en")) return "en";
   const locale = String(env.LC_ALL || env.LC_MESSAGES || env.LANG || "").toLowerCase();
   if (locale.startsWith("ru")) return "ru";
   return "en";
 }
 
+// Язык читается СИНХРОННО и одним полем: каталог строк нужен раньше, чем что-либо успеет
+// прочитать манифест целиком, а полный разбор отсюда звать нельзя — manifest.mjs сам берёт
+// строки здесь, и вышло бы кольцо. Чтобы этот сокращённый разбор не разошёлся с настоящим,
+// модульная проверка сверяет их ответы на одном и том же тексте.
+function langFromText(text) {
+  const m = String(text).match(/^lang:[ \t]*["']?([A-Za-z][A-Za-z-]*)/m);
+  return m ? m[1] : "";
+}
+
+function manifestLang(cwd = process.cwd()) {
+  try {
+    return { lang: langFromText(readFileSync(join(cwd, ".aqk.yml"), "utf8")) };
+  } catch {
+    // Манифеста нет или он нечитаем — не повод падать: язык просто выберется дальше по порядку.
+    return null;
+  }
+}
+
 const CATALOGS = { ru, en };
-const LANG = pickLang();
+const LANG = pickLang(process.env, manifestLang());
 const L = CATALOGS[LANG];
 
-export { L, LANG, pickLang, CATALOGS };
+export { L, LANG, pickLang, langFromText, CATALOGS };

package/tool/i18n/ru-docs.mjs

@@ -7,6 +7,47 @@
 // вторые — он же в терминале, одну секунду.
 
 const ruDocs = {
+  // Блок vitals переехал сюда 2026-09-09 по той же причине, что и brief: терминальный
+  // каталог снова перерос 500 строк, и поймал это наш же file-size-limit.
+  vitals: {
+    title: "Подключено ли то, чем комплект работает",
+    names: {
+      tools: "инструменты гейтов",
+      manifest: "манифест разобран",
+      preCommit: "хук pre-commit",
+      sessionHook: "состояние агенту",
+      version: "версия",
+    vitals: "подключено ли то, чем комплект работает: инструменты, хуки, свежесть",
+    },
+    toolsOk: (n) => `все ${n} на месте`,
+    toolsMissing: (l) => `НЕ НАЙДЕНЫ: ${l} — эти гейты не состоятся`,
+    manifestOk: "разобран целиком",
+    manifestBad: (n) => `${n} строк не разобраны и НЕ ДЕЙСТВУЮТ — подробности в doctor`,
+    unknownHook: "посмотреть не смогли — неизвестно, а не «нет»",
+    preCommitOk: "прописан в .git/hooks",
+    preCommitNo: "в .git/hooks его нет: запись в конфиге — намерение, а не защита",
+    sessionOk: "хук SessionStart отдаёт состояние агенту",
+    sessionNo: (cmd) => `агент не получает состояние: ${cmd}`,
+    versionOk: (v) => `${v}, свежая`,
+    versionUnknown: (v) => `${v}, до реестра не дозвонились — свежая ли, неизвестно`,
+    versionOld: (l, cur) => `есть ${l}, у вас ${cur}`,
+  },
+  // Блок краткого вывода переехал сюда 2026-09-09: терминальный каталог снова перерос
+  // 500 строк, и поймал это наш же file-size-limit. Шов по смыслу условен — это всё-таки
+  // терминал, — но предел настоящий, а делить пополам хуже, чем делить по соседству.
+  brief: {
+    name: "AQK",
+    held: (n) => `держит ${n}`,
+    todo: (n) => `не поставлено ${n}`,
+    levelUnknown: "уровень неизвестен",
+    red: (l) => `     КРАСНЫЕ: ${l}`,
+    advise: (slug, why) => `     ↑ поставить: ${slug} — ${why}`,
+    adviseOff: (cmd, env) => `       не нужно: ${cmd}, либо ${env}`,
+    update: (l, c, how) => `новая версия ${l}, у вас ${c} — обновить: ${how}`,
+    updateHow: "npx agent-quality-kit@latest, либо npm i -g agent-quality-kit",
+    updateHookHow: "pre-commit autoupdate",
+    updateOff: (env) => `       не нужно: ${env}`,
+  },
   // БЛОК СОСТОЯНИЯ — единственный наш текст, у которого читатель машина, а не человек.
   // Уходит в контекст агента хуком SessionStart, поэтому пишется как утверждения о факте:
   // без вежливости, без вводных, каждая строка либо факт, либо честное «неизвестно».
@@ -28,6 +69,13 @@ const ruDocs = {
     runRed: (when, names) => `Последний прогон ${when} — КРАСНЫЕ: ${names}.`,
     andMore: (n) => `и ещё ${n}`,
     skipped: (n) => `Не запускались: ${n} — инструмента нет на этой машине, их состояние неизвестно.`,
+    probeNever: "Проба покрытия не делалась — что здесь не прикрыто ничем, НЕИЗВЕСТНО. Это не «прикрыто»: `aqk probe`.",
+    probeBlind: (n, behind) =>
+      `Не прикрыто ничем: ${n} классов брака в местах, куда чаще всего возвращаются с починкой` +
+      (behind ? ` (проба отстала на ${behind} коммитов)` : "") + ". Подробно: `aqk probe`.",
+    probeClean: (behind) =>
+      "Проба покрытия: в проверенных местах каждый применимый класс кто-то ловит" +
+      (behind ? ` (отстала на ${behind} коммитов)` : "") + ".",
     ratchets: (list) => `Храповики: ${list}. Список может только укорачиваться, увеличивать нельзя.`,
     where: (entry) => `Свод правил: ${entry}. Чем доказан диф: \`aqk report --since main\`.`,
     mapTitle: "ЧТО УМЕЕТ ЭТОТ ИНСТРУМЕНТ. Полный список команд — не пересказ, а тот же список,\nиз которого собрана справка:",