kaloko 0.4.0 → 0.4.1

package/README.md

@@ -1,12 +1,12 @@
 # Kaloko
 
-Acceptance QA walkthroughs rendered as a shareable flow canvas.
+See what your agent built, on one canvas, and sign it off.
 
-Your coding agent (Claude Code, Codex or any LLM with a shell) runs QA from
-your acceptance plan with the `kaloko` skill. Kaloko captures every screen and
-e-mail of the flow, checks the criteria and builds a canvas that shows the
-whole flow (screens, branches, locales, evidence) for review, sign-off and
-living documentation.
+Your coding agent (Claude Code, Codex or any LLM with a shell) walks your
+acceptance plan with the `kaloko` skill. Kaloko captures every screen and
+e-mail of the flow, checks the criteria and lays the whole flow out on a
+canvas: screens, branches, locales and evidence. People review and approve it
+there, and the newest captures double as documentation.
 
 - Product and guides: <https://kaloko.app>
 - Service (organizations, shared canvases, reviews): <https://kaloko.app>
@@ -32,9 +32,9 @@ after `npm update kaloko` to refresh the skill.
 
 ## Then ask your agent
 
-With the skill installed you do not type the commands below; the agent does.
-It writes the acceptance plan and the scenario from the task, walks the
-screens, evaluates, shares the canvas and later processes reviewers' feedback.
+With the skill installed, the agent types the commands below, not you. It
+writes the acceptance plan and the scenario from the task, walks the screens,
+evaluates, shares the canvas and later works through what reviewers said.
 For example:
 
 > Read the task in docs/tasks/TASK-123, write its acceptance plan and a Kaloko
@@ -66,8 +66,8 @@ token, environment URL, evaluator key), `npx kaloko doctor` says what to fix.
 
 ## Design (Kaloko Design)
 
-Design the screens of a flow as live HTML with your own agent and skills, in the same scenario development and
-QA use. A design environment (`kind: design`, a folder of steps) is walked and synced into a shared draft the
+Design the screens of a flow as live HTML with your own agent and skills, in the same scenario that development
+and QA use. A design environment (`kind: design`, a folder of steps) is walked and synced into a shared draft the
 team sees live; `kaloko share` there publishes a version of the flow (unchanged steps are stored once). An
 accepted version becomes the design reference, and `packs: [design]` checks every implementation run against
 it (pixels, structure, tokens, contrast). See `skills/kaloko/reference/design.md`, `docs/GLOSSARY.md` and
@@ -87,7 +87,7 @@ for pages that work everywhere are in `skills/kaloko/reference/portable-html.md`
 
 ## Your data is yours: formats
 
-Nothing in Kaloko is stored in a format only Kaloko reads. Every export opens from disk without Kaloko:
+Nothing in Kaloko is stored in a format only Kaloko can read. Every export opens from disk without it:
 
 | Export | Command | Formats |
 |---|---|---|

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "kaloko",
-  "version": "0.4.0",
+  "version": "0.4.1",
   "description": "See what your AI agents built: every screen, language and device walked, assessed and approved on one canvas.",
   "keywords": [
     "qa",

package/schemas/scenario.v1.json

@@ -487,6 +487,8 @@
             "link_matches",
             "http_status",
             "link_home",
+            "links_ok",
+            "hreflang_pairs",
             "app_touch_targets",
             "app_no_truncation",
             "app_no_crash",
@@ -508,10 +510,12 @@
           ]
         },
         "selector": {
-          "type": "string"
+          "type": "string",
+          "description": "CSS selector; links_ok: the links to check (default a[href])."
         },
         "pattern": {
-          "type": "string"
+          "type": "string",
+          "description": "Regex; links_ok: link paths to skip."
         },
         "attr": {
           "type": "string"
@@ -526,17 +530,23 @@
         },
         "min": {
           "type": "integer",
-          "minimum": 0
+          "minimum": 0,
+          "description": "count: at least; http_status: lowest status; hreflang_pairs: languages required (default 2)."
         },
         "max": {
           "type": "integer",
-          "minimum": 0
+          "minimum": 0,
+          "description": "count: at most; http_status: highest status; perf_*: the limit; links_ok: links checked per page (default 100)."
         },
         "ratio": {
           "type": "number",
           "minimum": 0,
           "description": "design_pixels: maximum share of differing pixels (default 0.03)."
         },
+        "follow": {
+          "type": "boolean",
+          "description": "links_ok: follow links even when neither the environment nor the scenario is readonly (GET from an isolated copy of the session; links that look like actions are never followed)."
+        },
         "flags": {
           "type": "string",
           "pattern": "^[imsu]{0,4}$",

package/skills/kaloko/reference/acceptance.md

@@ -187,6 +187,27 @@ button styled uppercase reads `VYTVOŘIT`. Add `flags: i` to ignore case
 white-label check for `vyvolej` also matches the Czech verb "Vyvolej si";
 anchor it (`vyvolej\.to`).
 
+Two checks need the network and run next to the capture, once per page:
+
+- `links_ok`: every same-origin link (`selector`, default `a[href]`) answers
+  below 400 after redirects. `max` caps the links per page (default 100),
+  `pattern` skips matching paths. Redirects are listed in the evidence.
+  Links are followed only on a readonly environment or scenario; elsewhere
+  the criterion is not evaluated unless the check sets `follow: true`. Links
+  that look like actions (log out, unsubscribe, delete, remove, tokens,
+  switching organization) are never requested.
+- `hreflang_pairs`: at least `min` languages (default 2); the page's own
+  language points to the page itself; every other version answers 200
+  without a redirect and links back. This is what search engines require
+  of hreflang; a count of `link[hreflang]` does not prove it.
+
+Both are GETs from a separate request context that starts with a copy of
+the walk's cookies and the environment's gate and never writes back (a
+`?lang=` link cannot switch the language of the next step). They are cached
+per environment, locale and sign-in state, so a stack of hundreds of pages
+fetches its shared navigation once. A recheck
+from stored HTML keeps their last result; capture again to refresh them.
+
 Describe every relevant variant as nodes and `alt` edges, even when a given
 run covers only part of it. Decisions are `kind: decision` nodes.
 

package/skills/kaloko/reference/collaboration.md

@@ -1,7 +1,7 @@
 # Collaboration: share, feedback, inbox
 
-A run becomes useful when the people who decide can see it. The loop that
-works for teams using Kaloko:
+A run is only worth something once the people who decide have seen it. The
+loop teams use:
 
 1. **Share the run** (`kaloko share`, tester token, after asking). The
    command prints the canvas URL.

package/skills/kaloko/reference/evaluation.md

@@ -22,9 +22,8 @@ evaluating the same capture again costs nothing. `evaluators.jev.hosted: false`
 When neither is available, or the allowance is used up, semantic criteria stay `not_evaluated`; say so in the
 report with the reason `kaloko evaluate` gives.
 
-Results are cached by content hash, so re-running is cheap. The default
-evaluator is text-only and most accurate in English; it is weak at numbers,
-which is why those are deterministic.
+The default evaluator is text-only and most accurate in English. It is weak
+at numbers, which is why those are checked deterministically.
 
 When a criterion comes back `needs_review`, read the reduced state the
 evaluator saw (`steps/<node>/<locale>/<viewport>.capture.json`, key `state`)

package/src/cli.mjs

@@ -12,7 +12,8 @@ import { startBrowser, stopBrowser, connectBrowser, currentPage, launchEphemeral
 import { captureStep, captureCrop, captureOptions, acceptDialogs } from './lib/capture.mjs'
 import { observeConsole } from './lib/console.mjs'
 import { mailClient, waitForMessage, recipient, readMessageFile } from './lib/mail.mjs'
-import { newContext, accountFor, gateHeaders, gateOrigins, originMatcher } from './lib/access.mjs'
+import { newContext, accountFor, gateHeaders, gateOrigins, originMatcher, gateForRequests } from './lib/access.mjs'
+import { configureGate } from './lib/linkcheck.mjs'
 import { rememberEnvironment } from './lib/secrets.mjs'
 import { evaluateRun, semanticPrefetch } from './lib/evaluate.mjs'
 import { buildManifest, writePreview } from './lib/build.mjs'
@@ -664,6 +665,7 @@ const commands = {
       } finally { await enc?.close().catch(() => {}) }
       return
     }
+    configureGate(await gateForRequests(env, { root }))
     let conn = await connectBrowser({ root, config, env })
     let ephemeral = null
     let page
@@ -727,6 +729,7 @@ const commands = {
     const pick = list(args.steps)
     const locales = list(args.locales) || run.meta.scope.locales
     // --ephemeral: an own browser (own cookies and tabs) even when the shared one runs, so runs can walk in parallel
+    configureGate(await gateForRequests(env, { root }))
     const conn = args.ephemeral ? null : await connectBrowser({ root, config, env })
     const releaseLock = conn ? await acquireWalkLock({ root, config, env, run: run.meta.id }).catch(async (e) => { await conn.browser.close(); throw e }) : null
     const ephemeral = conn ? null : await launchEphemeral(config)

package/src/lib/access.mjs

@@ -119,6 +119,13 @@ export async function contextOptions (env, { root, config, account } = {}) {
   return options
 }
 
+/** The gate for requests made outside the browser (link checks): headers for the gate's origins only, Basic, mTLS. */
+export async function gateForRequests (env, { root } = {}) {
+  const headers = gateHeaders(env)
+  const options = await contextOptions(env, { root })
+  return { headers, toGate: Object.keys(headers).length ? originMatcher(gateOrigins(env)) : () => false, httpCredentials: options.httpCredentials || null, clientCertificates: options.clientCertificates || [] }
+}
+
 /** A new browser context with the environment's gate, policy and (optionally) an account's session. */
 export async function newContext (browser, env, opts = {}) {
   const context = await browser.newContext(await contextOptions(env, opts))

package/src/lib/capture.mjs

@@ -55,6 +55,7 @@ import { criteriaHash } from './evaluate.mjs'
 import { consoleEntriesFor } from './console.mjs'
 import { redact, redactDeep } from './secrets.mjs'
 import { readFields } from './stack.mjs'
+import { checkLinks, checkHreflang, requester, walkCache, NETWORK_ASSERTS, isolatedRequest, cacheScope } from './linkcheck.mjs'
 
 /** Probe arguments derived from the node's criteria. */
 export function probeArgs (node, maxChars, design = false) {
@@ -101,6 +102,7 @@ export async function captureStep ({ page, node, locale, viewports, run, console
   const paths = runPaths(run.dir)
   const original = page.viewportSize()
   const results = []
+  let netResults = null
   for (const [viewport, [width, height]] of Object.entries(viewports)) {
     const now = page.viewportSize()
     if (!now || now.width !== width || now.height !== height) await page.setViewportSize({ width, height })
@@ -153,6 +155,12 @@ export async function captureStep ({ page, node, locale, viewports, run, console
     const ownStatus = (e) => result.http_status >= 400 && /^Failed to load resource: the server responded with a status of \d+/.test(e.text) && e.src && sameDocument(e.src, url)
     const errors = consoleEntries.filter((e) => e.type !== 'blocked' && sameDocument(e.url, url) && !e.text.includes('ERR_BLOCKED_BY_CLIENT') && !ownStatus(e)).map((e) => e.text)
     const blocked = consoleEntries.filter((e) => e.type === 'blocked').map((e) => `${e.text}`)
+    // network checks (internal links, hreflang pairs) run once per page, outside the page, with a walk-wide cache
+    const net = (node.criteria || []).filter((c) => c.check.type === 'deterministic' && NETWORK_ASSERTS.has(c.check.assert))
+    if (net.length) {
+      netResults ||= await networkChecks(page, net, url, { run, locale })
+      Object.assign(result.checks, netResults)
+    }
     for (const c of node.criteria || []) {
       if (c.check.type === 'deterministic' && c.check.assert === 'no_console_errors') {
         result.checks[c.id] = collected === null
@@ -214,6 +222,50 @@ export async function captureCrop ({ page, node, locale, selector, title, run, p
   return entry
 }
 
+/**
+ * links_ok and hreflang_pairs for the current page: { [criterion id]: { ok, evidence } }. The requests go through an
+ * isolated request context (linkcheck.mjs), so the walker's cookies, language and session stay as they were.
+ * links_ok follows links only on a readonly environment or scenario, or when the check says `follow: true`.
+ */
+export async function networkChecks (page, criteria, url, { run = null, locale = '', factory = null } = {}) {
+  const out = {}
+  const readonly = !!(run?.meta?.environment?.readonly || run?.meta?.scenario?.readonly)
+  const follows = (c) => c.check.assert !== 'links_ok' || readonly || c.check.follow === true
+  const todo = criteria.filter((c) => {
+    if (follows(c)) return true
+    out[c.id] = { ok: null, evidence: 'links not followed: the environment and scenario are not readonly (set follow: true on the check to opt in)' }
+    return false
+  })
+  if (!todo.length) return out
+  let request
+  let get
+  try {
+    request = await isolatedRequest(page.context(), { factory })
+    const { cookies = [] } = await page.context().storageState().catch(() => ({}))
+    get = requester(request, walkCache, cacheScope({ environment: run?.meta?.environment?.name || '', locale, cookies }))
+  } catch (error) {
+    for (const c of todo) out[c.id] = { ok: null, evidence: `network checks unavailable: ${error.message}` }
+    await request?.dispose().catch(() => {})
+    return out
+  }
+  try {
+    const doc = await page.evaluate((sels) => ({
+      lang: document.documentElement.getAttribute('lang') || '',
+      alternates: [...document.querySelectorAll("link[rel~='alternate'][hreflang][href]")].map((l) => ({ hreflang: l.getAttribute('hreflang').toLowerCase(), href: l.href })),
+      links: Object.fromEntries(sels.map((sel) => [sel, (() => { try { return [...document.querySelectorAll(sel)].map((a) => a.href).filter(Boolean) } catch { return [] } })()]))
+    }), [...new Set(todo.filter((c) => c.check.assert === 'links_ok').map((c) => c.check.selector || 'a[href]'))]).catch(() => null)
+    for (const c of todo) {
+      if (!doc) { out[c.id] = { ok: null, evidence: 'page could not be read for network checks' }; continue }
+      try {
+        out[c.id] = c.check.assert === 'links_ok'
+          ? await checkLinks({ links: doc.links[c.check.selector || 'a[href]'] || [], pageUrl: url, get, max: c.check.max ?? undefined, exclude: c.check.pattern || null })
+          : await checkHreflang({ alternates: doc.alternates, pageUrl: url, lang: doc.lang, get, min: c.check.min ?? 2 })
+      } catch (error) { out[c.id] = { ok: false, evidence: `check error: ${error.message}` } }
+    }
+  } finally { await request.dispose().catch(() => {}) }
+  return out
+}
+
 function sameDocument (a, b) {
   try {
     const x = new URL(a); const y = new URL(b)

package/src/lib/design-export.mjs

@@ -6,7 +6,7 @@ import { createWriteStream } from 'node:fs'
 import { Readable } from 'node:stream'
 import { pipeline } from 'node:stream/promises'
 import { gunzipSync } from 'node:zlib'
-import { join, dirname, relative, basename } from 'node:path'
+import { join, dirname, relative, basename, isAbsolute } from 'node:path'
 import yaml from 'js-yaml'
 import { zipStream } from './zip.mjs'
 import { UserError } from './util.mjs'
@@ -57,13 +57,24 @@ ${rows}
 `
 }
 
+/**
+ * A relative path inside the export, or a UserError: names come from the service's responses (file lists, step ids,
+ * locales), and none of them may leave the export folder (no "..", no absolute or drive paths, no backslashes).
+ */
+export function safeExportPath (p) {
+  const s = String(p ?? '')
+  const parts = s.split('/')
+  if (!s || s.length > 1024 || /[\\\u0000]/.test(s) || /^[a-zA-Z]:/.test(s) || isAbsolute(s) || parts.some((x) => !x || x === '.' || x === '..')) throw new UserError(`Refusing to write ${JSON.stringify(s.slice(0, 120))}: not a plain relative path inside the export.`)
+  return s
+}
+
 /** A folder or, when `out` ends with .zip, a zip with one top folder; put(path, bytes) then close(). */
 export function exportSink (out) {
-  if (!out.endsWith('.zip')) return { put: async (p, bytes) => { const t = join(out, p); await mkdir(dirname(t), { recursive: true }); await writeFile(t, bytes) }, close: async () => {} }
+  if (!out.endsWith('.zip')) return { put: async (p, bytes) => { const t = join(out, safeExportPath(p)); await mkdir(dirname(t), { recursive: true }); await writeFile(t, bytes) }, close: async () => {} }
   const top = basename(out, '.zip')
   const entries = []
   return {
-    put: async (p, bytes) => { entries.push({ name: `${top}/${p}`, body: bytes instanceof Uint8Array ? bytes : new TextEncoder().encode(bytes) }) },
+    put: async (p, bytes) => { entries.push({ name: `${top}/${safeExportPath(p)}`, body: bytes instanceof Uint8Array ? bytes : new TextEncoder().encode(bytes) }) },
     close: async () => { await mkdir(dirname(out), { recursive: true }); await pipeline(Readable.fromWeb(zipStream(entries)), createWriteStream(out)) }
   }
 }
@@ -109,6 +120,7 @@ export async function exportDesign ({ config, scenarioId, client, ref = 'design'
   for (const s of revs.steps.filter((x) => x.state === 'default')) {
     ;(pages[s.node] ||= {})[s.locale] = s.entry
     for (const [p, hash] of Object.entries(s.files)) {
+      safeExportPath(p) // checked before anything is written
       if (paths.has(p)) { if (paths.get(p).hash !== hash) clashes.push(p); continue }
       paths.set(p, { hash, revision: s.revision })
     }

package/src/lib/evaluate.mjs

@@ -23,7 +23,7 @@ export function combine ({ node, capture, jev, thresholds }) {
     if (c.check.type === 'deterministic') {
       const r = capture.checks?.[c.id]
       const verdict = r == null || r.ok == null ? 'not_evaluated' : r.ok ? 'pass' : 'fail'
-      const live = c.check.assert === 'no_console_errors' || c.check.assert === 'no_overflow' || c.check.assert === 'http_status' || /^perf_/.test(c.check.assert || '')
+      const live = c.check.assert === 'no_console_errors' || c.check.assert === 'no_overflow' || c.check.assert === 'http_status' || c.check.assert === 'links_ok' || c.check.assert === 'hreflang_pairs' || /^perf_/.test(c.check.assert || '')
       return { id: c.id, type: 'deterministic', verdict, evidence: r?.evidence ?? null, ...(capture.rechecked_at && !live ? { rechecked: true } : {}) }
     }
     if (c.check.type === 'semantic' && c.check.about === 'console' && !(capture.console_errors || []).length && capture.checks) {

package/src/lib/linkcheck.mjs

@@ -0,0 +1,149 @@
+// Checks that need the network, evaluated next to the capture (not inside the page):
+//   links_ok        every same-origin link on the page answers below 400 (after redirects)
+//   hreflang_pairs  the page's hreflang alternates name the page itself for its own language, and every other
+//                   language version answers and links back (reciprocal pairs, as search engines require)
+// Requests are GETs (pages often do not implement HEAD) from a separate request context that starts with a copy of
+// the page's cookies and the environment's gate, and never writes back: following a link (or fetching /?lang=en for
+// hreflang) must not change the language, session or anything else the walk sees next. Links that look like they act
+// (log out, unsubscribe, delete, tokens, switching organization) are never followed, and links_ok follows links only
+// on readonly environments or scenarios unless the check opts in (follow: true). Results are cached per environment,
+// locale and sign-in state for the walk, so shared navigation is fetched once.
+
+const DEFAULT_MAX_LINKS = 100
+/** Links that may act when followed with a session: never fetched by the checks. */
+export const SKIP_LINK = /(?:^|[/?&=_.-])(?:token|unsubscribe|delete|remove|log-?out|sign-?out|switch)/i
+const actionLink = (u) => SKIP_LINK.test(u.pathname + u.search)
+
+/** Comparable form of a URL: origin, path without a trailing slash (except the root), sorted query, no hash. */
+export function normUrl (href, base) {
+  try {
+    const u = new URL(href, base)
+    u.hash = ''
+    const params = [...u.searchParams.entries()].sort(([a, x], [b, y]) => (a === b ? (x < y ? -1 : 1) : a < b ? -1 : 1))
+    const path = u.pathname.length > 1 ? u.pathname.replace(/\/+$/, '') : '/'
+    return `${u.origin}${path}${params.length ? '?' + new URLSearchParams(params).toString() : ''}`
+  } catch { return null }
+}
+
+/** `<link rel="alternate" hreflang href>` entries of an HTML document (attributes in any order). */
+export function parseAlternates (html, base) {
+  const out = []
+  for (const tag of String(html || '').match(/<link\b[^>]*>/gi) || []) {
+    const attr = (name) => tag.match(new RegExp(`\\s${name}\\s*=\\s*(?:"([^"]*)"|'([^']*)'|([^\\s>]+))`, 'i'))?.slice(1).find((v) => v != null)
+    if (!/(^|\s)alternate(\s|$)/i.test(attr('rel') || '')) continue
+    const hreflang = attr('hreflang'); const href = attr('href')
+    if (hreflang && href) out.push({ hreflang: hreflang.toLowerCase(), href: new URL(href.replace(/&amp;/g, '&'), base).href })
+  }
+  return out
+}
+
+const short = (u, origin) => { try { const x = new URL(u); return x.origin === origin ? x.pathname + x.search : x.href } catch { return u } }
+
+/**
+ * links_ok: { links: [href], pageUrl, get(url) → { status, url, error? }, max?, exclude? } → { ok, evidence }.
+ * Only same-origin http(s) links count; fragments and the page itself are skipped.
+ */
+export async function checkLinks ({ links, pageUrl, get, max = DEFAULT_MAX_LINKS, exclude = null }) {
+  const origin = new URL(pageUrl).origin
+  const self = normUrl(pageUrl)
+  const skip = exclude ? new RegExp(exclude) : null
+  const targets = [...new Set(links.map((h) => { try { const u = new URL(h, pageUrl); u.hash = ''; return u.href } catch { return null } }).filter((h) => h && /^https?:/.test(h)))]
+    .filter((h) => new URL(h).origin === origin && normUrl(h) !== self && !actionLink(new URL(h)) && !(skip && skip.test(short(h, origin))))
+  const checked = targets.slice(0, max)
+  const broken = []; const redirected = []
+  for (const url of checked) {
+    const r = await get(url)
+    if (r.error || !(r.status < 400)) broken.push(`${short(url, origin)} → ${r.error || `HTTP ${r.status}`}`)
+    else if (r.url && normUrl(r.url) !== normUrl(url)) redirected.push(short(url, origin))
+  }
+  if (!checked.length) return { ok: true, evidence: 'no internal links on the page' }
+  const more = targets.length > checked.length ? ` (first ${checked.length} of ${targets.length})` : ''
+  const note = redirected.length ? `; ${redirected.length} redirect: ${redirected.slice(0, 3).join(', ')}` : ''
+  return broken.length
+    ? { ok: false, evidence: `${broken.length} of ${checked.length} internal links broken${more}: ${broken.slice(0, 5).join('; ')}${note}` }
+    : { ok: true, evidence: `${checked.length} internal links answer below 400${more}${note}` }
+}
+
+/**
+ * hreflang_pairs: { alternates: [{ hreflang, href }], pageUrl, lang, get(url) → { status, url, html?, error? }, min? }.
+ * Fails when there are fewer than `min` languages, when the page's own language does not point to the page, or
+ * when another language version does not answer 200 or does not link back to the page.
+ */
+export async function checkHreflang ({ alternates, pageUrl, lang, get, min = 2 }) {
+  const problems = []
+  const langs = alternates.filter((a) => a.hreflang !== 'x-default')
+  if (new Set(langs.map((a) => a.hreflang)).size < min) problems.push(`${new Set(langs.map((a) => a.hreflang)).size} hreflang language(s), expected ${min}`)
+  const self = normUrl(pageUrl)
+  const primary = String(lang || '').toLowerCase().split('-')[0]
+  const own = langs.find((a) => a.hreflang === String(lang || '').toLowerCase()) || langs.find((a) => a.hreflang.split('-')[0] === primary)
+  if (!primary) problems.push('html lang is not set, so the page\'s own hreflang cannot be identified')
+  else if (!own) problems.push(`no hreflang for the page's own language "${lang}"`)
+  else if (normUrl(own.href) !== self) problems.push(`hreflang ${own.hreflang} points to ${own.href}, not to this page (${pageUrl})`)
+  for (const alt of langs) {
+    if (alt === own) continue
+    if (actionLink(new URL(alt.href))) { problems.push(`${alt.hreflang} version ${alt.href} looks like an action link; not fetched`); continue }
+    const r = await get(alt.href, { html: true })
+    if (r.error || r.status !== 200) { problems.push(`${alt.hreflang} version ${alt.href} → ${r.error || `HTTP ${r.status}`}`); continue }
+    if (r.url && normUrl(r.url) !== normUrl(alt.href)) problems.push(`${alt.hreflang} version ${alt.href} redirects to ${r.url}`)
+    const back = parseAlternates(r.html, r.url || alt.href)
+    const mine = own ? own.hreflang : primary
+    const ret = back.find((b) => b.hreflang === mine) || back.find((b) => b.hreflang.split('-')[0] === primary)
+    if (!ret) problems.push(`${alt.hreflang} version does not link back with hreflang ${mine}`)
+    else if (normUrl(ret.href) !== self) problems.push(`${alt.hreflang} version links back to ${ret.href}, not to this page`)
+  }
+  return problems.length
+    ? { ok: false, evidence: problems.slice(0, 5).join('; ') }
+    : { ok: true, evidence: `${langs.map((a) => a.hreflang).join(', ')}: reciprocal, the own language points to this page` }
+}
+
+/**
+ * The environment's gate for the checks' own requests (set once per walk by the CLI): headers for the gate's origins
+ * only (third parties never see them), HTTP Basic credentials and client certificates.
+ */
+const GATE = { headers: {}, toGate: () => false, httpCredentials: null, clientCertificates: [] }
+export function configureGate ({ headers = {}, toGate = () => false, httpCredentials = null, clientCertificates = [] } = {}) {
+  Object.assign(GATE, { headers, toGate, httpCredentials, clientCertificates })
+}
+
+/**
+ * A request context of its own for the checks: a copy of the browser context's cookies and storage (so pages behind
+ * a sign-in answer as they do for the walker) that never writes back to the browser context.
+ * `factory` is Playwright's `request` (injectable for tests).
+ */
+export async function isolatedRequest (context, { factory = null } = {}) {
+  const storageState = await context.storageState()
+  const pw = factory || (await import('playwright')).request
+  return pw.newContext({
+    storageState,
+    ...(GATE.httpCredentials ? { httpCredentials: GATE.httpCredentials } : {}),
+    ...(GATE.clientCertificates?.length ? { clientCertificates: GATE.clientCertificates } : {})
+  })
+}
+
+/** Cache scope of a page: environment, locale and sign-in state (a digest of the cookies, never the cookies). */
+export function cacheScope ({ environment = '', locale = '', cookies = [] } = {}) {
+  const jar = cookies.map((c) => `${c.domain}|${c.path}|${c.name}=${c.value}`).sort().join(';')
+  let h = 0
+  for (let i = 0; i < jar.length; i++) h = (Math.imul(h, 31) + jar.charCodeAt(i)) | 0
+  return `${environment}|${locale}|${jar ? (h >>> 0).toString(36) : 'anonymous'}`
+}
+
+/** Cached GETs through a Playwright APIRequestContext (an isolated one, see isolatedRequest). */
+export function requester (request, cache = new Map(), scope = '') {
+  return async (url, { html = false } = {}) => {
+    const key = `${scope} ${html ? 'html' : 'status'} ${url}`
+    if (cache.has(key)) return cache.get(key)
+    const job = (async () => {
+      try {
+        const res = await request.get(url, { maxRedirects: 5, timeout: 15000, failOnStatusCode: false, ...(GATE.toGate(url) ? { headers: GATE.headers } : {}) })
+        return { status: res.status(), url: res.url(), ...(html ? { html: (await res.text()).slice(0, 500000) } : {}) }
+      } catch (error) { return { status: 0, error: String(error.message || error).split('\n')[0].slice(0, 120) } }
+    })()
+    cache.set(key, job)
+    return job
+  }
+}
+
+/** One cache per walk process: navigation links shared by hundreds of stack pages are fetched once. */
+export const walkCache = new Map()
+export const NETWORK_ASSERTS = new Set(['links_ok', 'hreflang_pairs'])

package/src/lib/recheck.mjs

@@ -13,7 +13,7 @@ import { contextOptions, prepareContext } from './access.mjs'
 import { launchEphemeral } from './browser.mjs'
 import { treeChecks } from './apps/tree.mjs'
 
-export const LIVE_ONLY = (assert) => assert === 'no_console_errors' || assert === 'no_overflow' || assert === 'http_status' || /^perf_/.test(assert)
+export const LIVE_ONLY = (assert) => assert === 'no_console_errors' || assert === 'no_overflow' || assert === 'http_status' || assert === 'links_ok' || assert === 'hreflang_pairs' || /^perf_/.test(assert)
 
 const withBase = (html, url) => {
   if (!url || /<base\s/i.test(html)) return html

package/src/lib/run.mjs

@@ -36,7 +36,7 @@ export async function createRun ({ output, scenario, scenarioFile, env, scope, g
     id,
     short,
     scenario_file: relative(root, scenarioFile),
-    scenario: { id: scenario.id, title: scenario.title, kind: scenario.kind || 'task', version: scenario.version ?? null, source: scenario.source ?? null, ...(scenario.archived ? { archived: true } : {}), ...(scenario.platform && scenario.platform !== 'web' ? { platform: scenario.platform } : {}) },
+    scenario: { id: scenario.id, title: scenario.title, kind: scenario.kind || 'task', version: scenario.version ?? null, source: scenario.source ?? null, ...(scenario.archived ? { archived: true } : {}), ...(scenario.readonly ? { readonly: true } : {}), ...(scenario.platform && scenario.platform !== 'web' ? { platform: scenario.platform } : {}) },
     environment: { name: env.name, base_url: env.base_url, readonly: env.readonly, ...(env.kind === 'design' ? { kind: 'design' } : {}) },
     scope,
     git,

package/viewer/index.html

@@ -668,16 +668,16 @@ details summary{cursor:pointer;font-size:12.5px;font-weight:500}
 const EMBEDDED = /*__QAWALK_RUN__*/null;
 if (!window.QAWALK_APP) { const el = document.getElementById('qawalk-app'); if (el) { try { window.QAWALK_APP = JSON.parse(el.textContent); } catch {} } }
 const I18N = {
-  cs: { makePublicVersion:'Zveřejnit verzi', draft:'Koncept', liveShared:'živě, sdíleno', publishHint:'Publikovat verzi uloží celé flow jako %V; nezměněné kroky se znovu použijí.', htmlView:'HTML pohled', htmlViewNote:'Statická kopie stránky: bez skriptů zákazníka, s přenesenými styly a obrázky, bez tajných údajů.', editTitle:'Upravit v plátně', editText:'Text', editKeep:'ponechat', editSave:'Uložit úpravu', editSaved:'Úprava uložena jako nová revize', editRebased:'Krok se mezitím změnil; úprava je na nejnovější revizi', editUnapplied:'Neuplatněno (prvek už neexistuje)', staleCapture:'Snímek je z předchozí revize; Živě ukazuje poslední úpravu.', branches:'Větve', mergeBranch:'Sloučit do main', mergeConflict:'Krok se změnil v obou větvích:', mergeTakeBranch:'Vzít z větve? (Zrušit = ponechat main)', branchMerged:'Sloučeno', acceptVersion:'Přijmout verzi', returnVersion:'Vrátit verzi', versionVerdict:'Verdikt verze', draftInfo:'Tento koncept je živý a sdílený: všichni, kdo ho mají otevřený, vidí změny hned, i změny agentů. Kroky ukládá kaloko sync nebo úprava v plátně; tlačítko Publikovat verzi uloží celé flow jako novou verzi.', changedSince:'Změněno od', noChangeSince:'Beze změny od', designEnv:'design', version:'Verze', versions:'Verze flow', publish:'Publikovat verzi', publishName:'Název verze (nepovinný)', published:'Publikováno', designRef:'reference designu', setDesignRef:'Nastavit jako referenci designu', unsetDesignRef:'Zrušit referenci designu', designRefHint:'Implementace se kontroluje proti referenci designu (pack design).', openDraft:'Otevřít koncept', liveMode:'Živě', shotMode:'Snímek', inspect:'Inspektor', pinComment:'Komentář k prvku', pickHint:'Klikněte na prvek v náhledu.', pinnedOn:'K prvku', unchangedSince:'beze změny od', unchangedSteps:'kroků beze změny', changedOnly:'Jen změněné', stepStatus:'Stav kroku', st_in_progress:'rozpracováno', st_ready_for_review:'k revizi', st_ready_for_dev:'připraveno pro vývoj', present:'Prezentovat', presenting:'Prezentujete', stopPresent:'Ukončit prezentaci', updatedSteps:'upravil', viaAgent:'přes', here:'tady', copyCss:'Kopírovat CSS', cssCopied:'CSS zkopírováno', noToken:'mimo sadu tokenů', tokenSet:'token', revisionBy:'revize', noLiveOrigin:'Živé kroky nejsou na této instanci zapnuté.', draftEmpty:'Koncept zatím nemá žádné kroky; spusťte kaloko sync.', prototypeTo:'Prototyp: přechod na', outdated:'zastaralé', prototype:'Prototyp', protoTitle:'Prezentovat prototyp', protoHint:'Klikejte v prototypu; ← → předchozí / další krok, Esc konec.', protoShot:'Jen snímky: živé kroky tu nejsou k dispozici. ← → procházejí flow.', protoLocal:'Odkazy otevírají stránky z disku; ← → procházejí flow.', protoDevice:'Rámeček zařízení', protoFull:'Celá obrazovka', protoExit:'Ukončit prototyp', protoNoStep:'Odkaz nevede na žádný krok flow',     hint:'Táhněte pro posun · Ctrl + kolečko zoom · <span class="kbd">F</span> režim soustředění · <span class="kbd">K</span> scénáře a běhy · <span class="kbd">R</span> projít · <span class="kbd">P</span> prototyp · <span class="kbd">I</span> mapa / index · <span class="kbd">←</span><span class="kbd">→</span> předchozí / další krok (v detailu) · <span class="kbd">Esc</span> zavřít', locale:'Testovaný jazyk', view:'Náhled', both:'Oba', shownRun:'Zobrazený běh', allRuns:'Všechny běhy', steps:'Kroky flow', fit:'Celé flow', stepsWord:'kroků', passedWord:'prošlo', fitLane:'Zobrazit celou sekci', following:'Sledujete', followEsc:'Esc ukončí', followHint:'Sledovat, co dělá', visOn:'Vidí mě ostatní', visOff:'Jsem skrytý',
+  cs: { makePublicVersion:'Zveřejnit verzi', draft:'Koncept', liveShared:'živě, sdíleno', publishHint:'Publikování uloží celé flow jako %V; nezměněné kroky se použijí znovu.', htmlView:'HTML pohled', htmlViewNote:'Statická kopie stránky: bez skriptů webu, s přenesenými styly a obrázky, bez tajných údajů.', editTitle:'Upravit na plachtě', editText:'Text', editKeep:'ponechat', editSave:'Uložit úpravu', editSaved:'Úprava uložena jako nová revize', editRebased:'Krok se mezitím změnil; úprava se uložila do nejnovější revize', editUnapplied:'Neuplatněno (prvek už neexistuje)', staleCapture:'Snímek je z předchozí revize; Živě ukazuje poslední úpravu.', branches:'Větve', mergeBranch:'Sloučit do main', mergeConflict:'Krok se změnil v obou větvích:', mergeTakeBranch:'Vzít z větve? (Zrušit = ponechat main)', branchMerged:'Sloučeno', acceptVersion:'Přijmout verzi', returnVersion:'Vrátit verzi', versionVerdict:'Verdikt verze', draftInfo:'Koncept je živý a sdílený: kdo ho má otevřený, vidí změny hned, i ty od agentů. Kroky ukládá kaloko sync nebo úprava na plachtě; tlačítko Publikovat verzi uloží celé flow jako novou verzi.', changedSince:'Změněno od', noChangeSince:'Beze změny od', designEnv:'design', version:'Verze', versions:'Verze flow', publish:'Publikovat verzi', publishName:'Název verze (nepovinný)', published:'Publikováno', designRef:'reference designu', setDesignRef:'Nastavit jako referenci designu', unsetDesignRef:'Zrušit referenci designu', designRefHint:'Implementace se kontroluje proti referenci designu (pack design).', openDraft:'Otevřít koncept', liveMode:'Živě', shotMode:'Snímek', inspect:'Inspektor', pinComment:'Komentář k prvku', pickHint:'Klikněte na prvek v náhledu.', pinnedOn:'K prvku', unchangedSince:'beze změny od', unchangedSteps:'kroků beze změny', changedOnly:'Jen změněné', stepStatus:'Stav kroku', st_in_progress:'rozpracováno', st_ready_for_review:'k revizi', st_ready_for_dev:'připraveno pro vývoj', present:'Prezentovat', presenting:'Prezentujete', stopPresent:'Ukončit prezentaci', updatedSteps:'upravil', viaAgent:'přes', here:'tady', copyCss:'Kopírovat CSS', cssCopied:'CSS zkopírováno', noToken:'mimo sadu tokenů', tokenSet:'token', revisionBy:'revize', noLiveOrigin:'Živé kroky nejsou na této instanci zapnuté.', draftEmpty:'Koncept zatím nemá žádné kroky; spusťte kaloko sync.', prototypeTo:'Prototyp: přechod na', outdated:'zastaralé', prototype:'Prototyp', protoTitle:'Prezentovat prototyp', protoHint:'Klikejte v prototypu; ← → předchozí / další krok, Esc konec.', protoShot:'Jen snímky: živé kroky tu nejsou k dispozici. ← → procházejí flow.', protoLocal:'Odkazy otevírají stránky z disku; ← → procházejí flow.', protoDevice:'Rámeček zařízení', protoFull:'Celá obrazovka', protoExit:'Ukončit prototyp', protoNoStep:'Odkaz nevede na žádný krok flow',     hint:'Táhněte pro posun · Ctrl + kolečko zoom · <span class="kbd">F</span> režim soustředění · <span class="kbd">K</span> scénáře a běhy · <span class="kbd">R</span> projít · <span class="kbd">P</span> prototyp · <span class="kbd">I</span> mapa / index · <span class="kbd">←</span><span class="kbd">→</span> předchozí / další krok (v detailu) · <span class="kbd">Esc</span> zavřít', locale:'Testovaný jazyk', view:'Náhled', both:'Oba', shownRun:'Zobrazený běh', allRuns:'Všechny běhy', steps:'Kroky flow', fit:'Celé flow', stepsWord:'kroků', passedWord:'prošlo', fitLane:'Zobrazit celou sekci', following:'Sledujete', followEsc:'Esc ukončí', followHint:'Sledovat, co dělá', visOn:'Vidí mě ostatní', visOff:'Jsem skrytý',
     pass:'Splněno', partial:'Částečně', fail:'Nesplněno', skip:'Neprověřeno', crop:'výřez', html:'HTML snapshot', email:'e-mail', external:'třetí strana',
     branch:'Větev', commit:'Commit', author:'Autor', pr:'PR', issue:'Issue', env:'Prostředí', duration:'Délka', noPr:'bez PR', open:'otevřený', merged:'sloučený', closed:'zavřený',
     older:'Starší běh', newer:'Novější běh', purpose:'Účel obrazovky ze scénáře', criteria:'Akceptační kritéria', jevTitle:'Sémantické hodnocení',
-    jevNote:'Evaluátor dostal zredukovaný stav stránky a vrátil pravděpodobnost pro každou otázku. Verdikt podle prahů a důkazy doplňuje runner.', evalLabel:'Hodnocení', metaTitle:'Metadata stránky', mdBasic:'Základ', mdHeadings:'Osnova nadpisů', mdHreflang:'Jazykové verze (hreflang)', mdOg:'Open Graph', mdTwitter:'Twitter / X', mdLd:'Strukturovaná data · JSON-LD', mdMicro:'Strukturovaná data · microdata', mdLinks:'Další odkazy v hlavičce', mdOther:'Ostatní meta', missing:'Chybí', duplicate:'duplicitní', size:'Velikost', runVerdict:'Verdikt běhu', accept:'Přijmout běh', ret:'Vrátit běh', pending:'čeká', accepted:'přijato', returned:'vráceno', baseline:'Referenční běh', setBaseline:'Nastavit jako referenční', unsetBaseline:'Zrušit referenci', verdictNotePh:'Poznámka k verdiktu (u vrácení povinná)', manualPass:'Splněno', manualFail:'Nesplněno', manualNotePh:'Důvod (u nesplněno povinný)', reviewerVerdict:'verdikt kontrolujícího', decideManual:'Rozhodnout ručně', consoleErrors:'Chyby konzole', consoleLoading:'Načítám zprávy…', noConsole:'U tohoto snímku se zprávy konzole neuložily.', consoleMore:(n) => `Dalších ${n} se neuložilo (ukládá se prvních 20).`, blockedTitle:'Zablokované požadavky', copyAll:'Kopírovat vše', copyOne:'Kopírovat tuto zprávu', copied:'Zkopírováno', tabOverview:'Kritéria', tabPage:'Stránka', tabTech:'Technické', toSolve:(n) => `k řešení ${n}`, passedN:(n) => `splněno ${n}`, whyMatters:'Proč na tom záleží:', howFix:'Jak opravit:', whyAndFix:'Proč na tom záleží a jak to opravit', aiShort:(p) => `AI ${p} % ano`, noneFailed:'Nic neselhalo.', toDecide:'Rozhodne člověk', toDecideLead:'AI si nebyla jistá nebo nemohla vyhodnotit; otevřete krok, podívejte se na snímek a rozhodněte.', worthLook:'Stojí za pohled', jevScoreHint:'Průměrná jistota AI, že sémantická kritéria této obrazovky jsou splněná', sigTitle:'Rychlé signály', sigLead:'AI se na ně ptá vedle kritérií u každé obrazovky. Výsledek nemění, jen upozorní na obrazovky, na které je dobré se podívat.', sigPurpose:'Plní účel kroku', sigLanguage:'Text v očekávaném jazyce', sigBroken:'Vypadá rozbitě (chyba, zástupný text, prázdno)', sigWarn:(n) => `Signály k prověření: ${n}`, sigYes:(p) => `${p} % ano`,
+    jevNote:'Evaluátor dostal zjednodušený stav stránky a ke každé otázce vrátil pravděpodobnost. Verdikt podle prahů a důkazy doplnil runner.', evalLabel:'Hodnocení', metaTitle:'Metadata stránky', mdBasic:'Základ', mdHeadings:'Osnova nadpisů', mdHreflang:'Jazykové verze (hreflang)', mdOg:'Open Graph', mdTwitter:'Twitter / X', mdLd:'Strukturovaná data · JSON-LD', mdMicro:'Strukturovaná data · microdata', mdLinks:'Další odkazy v hlavičce', mdOther:'Ostatní meta', missing:'Chybí', duplicate:'duplicitní', size:'Velikost', runVerdict:'Verdikt běhu', accept:'Přijmout běh', ret:'Vrátit běh', pending:'čeká', accepted:'přijato', returned:'vráceno', baseline:'Referenční běh', setBaseline:'Nastavit jako referenční', unsetBaseline:'Zrušit referenci', verdictNotePh:'Poznámka k verdiktu (u vrácení povinná)', manualPass:'Splněno', manualFail:'Nesplněno', manualNotePh:'Důvod (u nesplněno povinný)', reviewerVerdict:'verdikt kontrolujícího', decideManual:'Rozhodnout ručně', consoleErrors:'Chyby konzole', consoleLoading:'Načítám zprávy…', noConsole:'U tohoto snímku se zprávy konzole neuložily.', consoleMore:(n) => `Dalších ${n} se neuložilo (ukládá se prvních 20).`, blockedTitle:'Zablokované požadavky', copyAll:'Kopírovat vše', copyOne:'Kopírovat tuto zprávu', copied:'Zkopírováno', tabOverview:'Kritéria', tabPage:'Stránka', tabTech:'Technické', toSolve:(n) => `k řešení ${n}`, passedN:(n) => `splněno ${n}`, whyMatters:'Proč na tom záleží:', howFix:'Jak opravit:', whyAndFix:'Proč na tom záleží a jak to opravit', aiShort:(p) => `AI ${p} % ano`, noneFailed:'Nic neselhalo.', toDecide:'Rozhodne člověk', toDecideLead:'AI si nebyla jistá nebo nemohla vyhodnotit; otevřete krok, podívejte se na snímek a rozhodněte.', worthLook:'Stojí za kontrolu', jevScoreHint:'Průměrná jistota AI, že sémantická kritéria této obrazovky jsou splněná', sigTitle:'Rychlé signály', sigLead:'AI se na ně ptá u každé obrazovky spolu s kritérii. Výsledek nemění, jen ukáže obrazovky, na které se vyplatí podívat.', sigPurpose:'Plní účel kroku', sigLanguage:'Text v očekávaném jazyce', sigBroken:'Vypadá rozbitě (chyba, zástupný text, prázdno)', sigWarn:(n) => `Signály k prověření: ${n}`, sigYes:(p) => `${p} % ano`,
     howAuto:'Automatická kontrola', howAi:'Vyhodnocení AI', howManual:'Rozhoduje člověk', howTech:'Technický detail',
-    aiPass:(p, t) => `Hodnotitel si je na ${p} % jistý, že odpověď je ano; projde od ${t} %.`, aiFail:(p, t) => `Jen ${p} % ano; neprojde při ${t} % a méně.`, aiUnsure:(p, lo, hi) => `Nejisté: ${p} % ano, mezi ${lo} % a ${hi} %. Podívejte se na snímek a rozhodněte níže.`,
+    aiPass:(p, t) => `Evaluátor si je na ${p} % jistý, že odpověď je ano; projde od ${t} %.`, aiFail:(p, t) => `Jen ${p} % ano; neprojde při ${t} % a méně.`, aiUnsure:(p, lo, hi) => `Nejisté: ${p} % ano, mezi ${lo} % a ${hi} %. Podívejte se na snímek a rozhodněte níže.`,
     aiNotEval:'Zatím nevyhodnoceno.', aiVia:{ qawalk:'vyhodnotilo Kaloko', 'own-key':'vyhodnoceno vaším klíčem' }, aiAsked:'Otázka',
     a_exists:(s) => `${s} je na stránce`, a_absent:(s) => `${s} na stránce není`, a_count:(s, mn, mx) => `${s} se vyskytuje ${mn != null && mn === mx ? `přesně ${mn}×` : mn != null && mx != null ? `${mn}–${mx}×` : mn != null ? `aspoň ${mn}×` : mx != null ? `nejvýš ${mx}×` : ''}`, a_text_matches:(s, p) => `${s || 'Stránka'} obsahuje ${p}`, a_text_absent:(s, p) => `${s || 'Stránka'} neobsahuje ${p}`, a_attr_equals:(s, a, v) => `${s} má ${a} = ${v}`,
-    a_no_overflow:'Nic nepřetéká šířku obrazovky', a_no_console_errors:'V konzoli prohlížeče nejsou chyby', a_title_matches:(p) => `Titulek stránky odpovídá ${p}`, a_meta_matches:(s, p) => `Metadata ${s} odpovídají ${p}`, a_link_matches:(s) => `Odkazy ${s} vedou, kam mají`, a_http_status:(v) => `Server odpovídá ${v || '2xx'}`, a_link_home:'Stránka odkazuje zpět na úvod',
+    a_no_overflow:'Nic nepřetéká šířku obrazovky', a_no_console_errors:'V konzoli prohlížeče nejsou chyby', a_title_matches:(p) => `Titulek stránky odpovídá ${p}`, a_meta_matches:(s, p) => `Metadata ${s} odpovídají ${p}`, a_link_matches:(s) => `Odkazy ${s} vedou, kam mají`, a_http_status:(v) => `Server odpovídá ${v || '2xx'}`, a_link_home:'Stránka odkazuje zpět na úvod', a_links_ok:'Interní odkazy fungují (žádné 404)', a_hreflang_pairs:'Jazykové verze (hreflang) na sebe vzájemně odkazují',
     a_perf_lcp:(mx) => `Největší obsah se zobrazí do ${mx} ms`, a_perf_cls:'Rozvržení se při načítání nehýbe', a_perf_ttfb:(mx) => `Server začne odpovídat do ${mx} ms`, a_perf_weight:'Stránka je dost lehká na rychlé načtení',
     a_a11y:'Pravidlo přístupnosti', a_design:'Odpovídá referenci designu', a_uses_tokens:'Barvy, písma a velikosti pocházejí z tokenů', a_app:'Pravidlo aplikace', files:'souborů', storage:'Úložiště', copyLink:'Kopírovat odkaz', linkCopied:'Odkaz zkopírován', noPlaceToast:'Toto kritérium nemá místo na stránce ani v metadatech; důkaz je v textu kritéria.', noMeta:'Tento běh je starší a metadata stránky nesbíral. Spusťte nový běh.', noBoxToast:'Prvek se na tomto snímku nenašel.', onPage:'na stránce', inMeta:'v metadatech', inConsole:'v konzoli', noPlace:'bez místa na stránce', clickHl:'Klikněte na kritérium: zvýrazní ho na stránce nebo v metadatech', invalidJson:'neplatný JSON', attachments:'Přílohy kroku', tech:'Technické údaje',
     execution:'Provedení kroku', step:'Krok', of:'z', hover:'Klikněte na kritérium: zvýrazní ho na stránce nebo v metadatech', fullPage:'celá stránka',
@@ -687,21 +687,21 @@ const I18N = {
     allAbove:'Všechny otázky nad prahem', review:'k revizi', notEvaluated:'nehodnoceno', search:'Hledat scénář, task, cestu…', all:'Vše', tasks:'Úkoly', flows:'Flow',
     runs:'běhů', last:'poslední', time:'Čas', result:'Výsledek', noRuns:'Žádný běh neodpovídá filtrům.', noScenario:'Žádný scénář neodpovídá hledání.',
     onlyLocal:'Tento běh je jen lokálně; otevřete jeho složku.', linksExpired:'Odkazy na snímky vypršely. Obnovte stránku.', captured:'Zachyceno', console:'Konzole', errors:'chyb', blocked:'blokovaných požadavků', files:'Soubory',
-    pagesWord:'stránek', firstScreen:'první obrazovka', layout:'Rozložení', uploadedBy:'Nahrál', addNote:'Přidat poznámku', viewOptions:'Zobrazení', keyComment:'komentář ke kroku (v detailu)', keyHelp:'tato nápověda', helpTitle:'Zkratky a nápověda', flowComments:'Komentáře k flow', runComments:'Komentáře k běhu', commentsTitle:'Komentáře', allOpen:'Otevřené', openWord:'otevřených', flowCommentsLead:'Platí pro celé flow napříč běhy: chybějící krok, obecná připomínka, nápad.', noStepComments:'Ke kroku zatím nikdo nic nenapsal.', noComments:'Zatím žádné komentáře.', showResolved:'Vyřešené', hideResolved:'Skrýt vyřešené', replyAct:'Odpovědět', reopenAct:'Znovu otevřít', editAct:'Upravit', deleteAct:'Smazat', saveAct:'Uložit', cancel:'Zrušit', edited:'upraveno', commentDeleted:'Komentář byl smazán.', viaAgent:'Napsal agent', showPin:'Ukázat na snímku', pinOnShot:'Připnout na snímek', pinClickShot:'Klikněte do snímku', pinnedOnShot:'Připnuto na snímek', replyPh:'Odpověď… (@jméno upozorní)', flowPh:'Komentář k celému flow… (@jméno upozorní)', runPh:'Komentář k celému běhu… (@jméno upozorní)', commentLabel:'Komentář', ctrlEnter:'Ctrl+Enter odešle', confirmDelete:'Smazat komentář?', deletedToast:'Smazáno', openCommentsN:'Nevyřízené komentáře', showAllN:'Zobrazit všech %N%', screenWord:'obrazovka aplikace', uiTree:'UI strom', platformWord:'Platforma', treeHint:'Klikněte na prvek: ukáže ho na snímku.', treeSearch:'Hledat v UI stromu…', treeOcr:'Text rozpoznaný ze snímku (OCR): bez rolí a ovládacích prvků.', treeLoadFail:'UI strom se nepodařilo načíst.', treeEmpty:'Strom je prázdný.', mapView:'Mapa', indexView:'Index', searchSteps:'Hledat v krocích, kritériích a stránkách…', criteriaCol:'Kritéria', notesCol:'Poznámky', noStepsMatch:'Žádný krok neodpovídá filtru.', riKeys:'/ hledat · ↑↓ vybrat · Enter otevřít · I mapa', consoleWord:'chyb v konzoli', loadingPages:'hledám i ve stránkách stacků…', sortTitle:'Název', runWord:'Běh', openIndex:'Otevřít index', pagesNeedAttention:'stránek chce pozornost', allPagesPass:'všechny stránky prošly', stackLoadFail:'Index stránek se nepodařilo načíst', semanticSample:'sémantický vzorek', downloadCsv:'Stáhnout CSV', allWord:'Vše', criterionFilter:'Neprošlé kritérium', anyCriterion:'Jakékoli kritérium', searchPages:'Hledat v titulku, URL a polích…', sortBy:'Řadit podle', sortOrder:'Pořadí', sortStatus:'Stav (nejhorší první)', sortDir:'Směr řazení', pageWord:'Stránka', statusWord:'Stav', failingCriteria:'Neprošlo', stackKeys:'/ hledat · ↑↓ vybrat · Enter otevřít · Esc zavřít', listView:'Seznam', gridView:'Mřížka', noPagesMatch:'Filtru neodpovídá žádná stránka.', backToIndex:'Zpět na index',
+    pagesWord:'stránek', firstScreen:'první obrazovka', layout:'Rozložení', uploadedBy:'Nahrál', addNote:'Přidat poznámku', viewOptions:'Zobrazení', keyComment:'komentář ke kroku (v detailu)', keyHelp:'tato nápověda', helpTitle:'Zkratky a nápověda', flowComments:'Komentáře k flow', runComments:'Komentáře k běhu', commentsTitle:'Komentáře', allOpen:'Otevřené', openWord:'otevřených', flowCommentsLead:'Platí pro celé flow napříč běhy: chybějící krok, obecná připomínka, nápad.', noStepComments:'Ke kroku zatím nikdo nic nenapsal.', noComments:'Zatím žádné komentáře.', showResolved:'Vyřešené', hideResolved:'Skrýt vyřešené', replyAct:'Odpovědět', reopenAct:'Znovu otevřít', editAct:'Upravit', deleteAct:'Smazat', saveAct:'Uložit', cancel:'Zrušit', edited:'upraveno', commentDeleted:'Komentář byl smazán.', viaAgent:'Napsal agent', showPin:'Ukázat na snímku', pinOnShot:'Připnout na snímek', pinClickShot:'Klikněte do snímku', pinnedOnShot:'Připnuto na snímek', replyPh:'Odpověď… (@jméno upozorní)', flowPh:'Komentář k celému flow… (@jméno upozorní)', runPh:'Komentář k celému běhu… (@jméno upozorní)', commentLabel:'Komentář', ctrlEnter:'Ctrl+Enter odešle', confirmDelete:'Smazat komentář?', deletedToast:'Smazáno', openCommentsN:'Nevyřízené komentáře', showAllN:'Zobrazit všech %N%', screenWord:'obrazovka aplikace', uiTree:'UI strom', platformWord:'Platforma', treeHint:'Klikněte na prvek: ukáže ho na snímku.', treeSearch:'Hledat v UI stromu…', treeOcr:'Text rozpoznaný ze snímku (OCR): bez rolí a ovládacích prvků.', treeLoadFail:'UI strom se nepodařilo načíst.', treeEmpty:'Strom je prázdný.', mapView:'Mapa', indexView:'Index', searchSteps:'Hledat v krocích, kritériích a stránkách…', criteriaCol:'Kritéria', notesCol:'Poznámky', noStepsMatch:'Žádný krok neodpovídá filtru.', riKeys:'/ hledat · ↑↓ vybrat · Enter otevřít · I mapa', consoleWord:'chyb v konzoli', loadingPages:'hledám i ve stránkách stacků…', sortTitle:'Název', runWord:'Běh', openIndex:'Otevřít index', pagesNeedAttention:'stránek chce pozornost', allPagesPass:'všechny stránky prošly', stackLoadFail:'Index stránek se nepodařilo načíst', semanticSample:'sémantický vzorek', downloadCsv:'Stáhnout CSV', allWord:'Vše', criterionFilter:'Nesplněné kritérium', anyCriterion:'Jakékoli kritérium', searchPages:'Hledat v titulku, URL a polích…', sortBy:'Řadit podle', sortOrder:'Pořadí', sortStatus:'Stav (nejhorší první)', sortDir:'Směr řazení', pageWord:'Stránka', statusWord:'Stav', failingCriteria:'Neprošlo', stackKeys:'/ hledat · ↑↓ vybrat · Enter otevřít · Esc zavřít', listView:'Seznam', gridView:'Mřížka', noPagesMatch:'Filtru neodpovídá žádná stránka.', backToIndex:'Zpět na index',
     subject:'Předmět', from:'Od', to:'Komu', received:'Přijato', mailBeforeRun:'přišel před začátkem běhu', noCapture:'Bez snímku', viewEval:'eval.json', decision:'rozhodnutí', mainLane:'Hlavní průchod',
-    downloadZip:'Stáhnout ZIP', downloadZipNote:'Všechny soubory v otevřených formátech a plátno, které se otevře offline z disku', filesWord:'souborů', publicAccess:'veřejný odkaz', orgAccess:'přístup po přihlášení do organizace', projectAll:'Všechny projekty', packNote:'Kritérium z balíčku kontrol (packs ve scénáři)', coverage:'Pokrytí plánu', coverageLine:'kritérií z ACCEPTANCE.md má kontrolu', coverageExtra:'kontrol mimo plán', coverageFull:'Každé plánované kritérium má kontrolu.', coverageSteps:'Kroky v plánu bez uzlu', flakyTitle:'Nestabilní kritéria', flaky:'nestabilní', flakyNote:'Verdikt se liší mezi běhy na stejném commitu a prostředí.', people:'Lidé ve flow', peopleHint:'Klik na osobu zvýrazní její kroky; přerušované šipky jsou předání mezi lidmi.', awaiting:'Čeká na schválení od', approvedBy:'schválili', approvedByAll:'Schválili všichni povinní schvalovatelé.', publicRun:'Veřejný běh', publicNote:'Plachta je čitelná bez přihlášení; jména hodnotitelů jsou skrytá.', makePublic:'Zveřejnit běh', makePrivate:'Zrušit zveřejnění', publicHint:'Jen pro scénáře bez osobních údajů', publicConfirm:'Zveřejnit tento běh? Uvidí ho kdokoli s odkazem, bez přihlášení. Použijte jen u scénářů bez osobních údajů.', openInApp:'Otevřít v Kaloku', signInLink:'Přihlásit', replay:'Projít', rpStep:'Krok', rpNext:'Další', rpPrev:'Zpět', rpEnd:'Konec průchodu.', rpRestart:'Znovu od začátku', rpChoose:'Kudy dál?', rpOr:'nebo', rpKeys:'← → krok · čísla volí větev · Esc zavře', rpDecision:'Rozhodnutí', rpBranch:'větev', rpAltOnly:'jiná větev',
+    downloadZip:'Stáhnout ZIP', downloadZipNote:'Všechny soubory v otevřených formátech a plachta, která se otevře offline z disku', filesWord:'souborů', publicAccess:'veřejný odkaz', orgAccess:'přístup po přihlášení do organizace', projectAll:'Všechny projekty', packNote:'Kritérium z balíčku kontrol (packs ve scénáři)', coverage:'Pokrytí plánu', coverageLine:'kritérií z ACCEPTANCE.md má kontrolu', coverageExtra:'kontrol mimo plán', coverageFull:'Každé plánované kritérium má kontrolu.', coverageSteps:'Kroky v plánu bez uzlu', flakyTitle:'Nestabilní kritéria', flaky:'nestabilní', flakyNote:'Verdikt se liší mezi běhy na stejném commitu a prostředí.', people:'Lidé ve flow', peopleHint:'Kliknutím na osobu zvýrazníte její kroky; přerušované šipky ukazují předání mezi lidmi.', awaiting:'Čeká na schválení od', approvedBy:'schválili', approvedByAll:'Schválili všichni povinní schvalovatelé.', publicRun:'Veřejný běh', publicNote:'Plachta je čitelná bez přihlášení; jména hodnotitelů jsou skrytá.', makePublic:'Zveřejnit běh', makePrivate:'Zrušit zveřejnění', publicHint:'Jen pro scénáře bez osobních údajů', publicConfirm:'Zveřejnit tento běh? Uvidí ho kdokoli s odkazem, bez přihlášení. Použijte jen u scénářů bez osobních údajů.', openInApp:'Otevřít v Kaloku', signInLink:'Přihlásit', replay:'Projít', rpStep:'Krok', rpNext:'Další', rpPrev:'Zpět', rpEnd:'Konec průchodu.', rpRestart:'Znovu od začátku', rpChoose:'Kudy dál?', rpOr:'nebo', rpKeys:'← → krok · čísla volí větev · Esc zavře', rpDecision:'Rozhodnutí', rpBranch:'větev', rpAltOnly:'jiná větev',
     compare:'Porovnat', cmpOff:'nic', cmpBaseline:'referenční', cmpPrev:'předchozí', cmpTitle:'Rozdíly oproti', cmpNone:'Statusy, verdikty i evidence jsou stejné.', pxChanged:'pixelů jinak', cmpSide:'Vedle sebe', cmpDiff:'Rozdíl', cmpLoadErr:'Porovnávaný běh se nepodařilo načíst.', pxUnavail:'Pixelový rozdíl se počítá jen ve službě (snímky ze stejného původu).', was:'předtím', thisRun:'tento běh', cmpNoCap:'v porovnávaném běhu bez snímku', cmpAdded:'nové kroky', cmpRemoved:'kroky, které zmizely', cmpHint:'Ctrl/⌘ + klik na krok otevře porovnání',
     reviewTitle:'Akceptace a komentáře', approve:'Schválit', reject:'Zamítnout', comment:'Komentovat', notePh:'Co je potřeba změnit, nebo poznámka · @jméno pošle kolegovi upozornění', approved:'schváleno', rejected:'zamítnuto', commented:'komentář', resolved:'vyřešeno', resolve:'Vyřešit', openFeedback:'Otevřená zpětná vazba', noFeedback:'Žádná otevřená zpětná vazba.', saved:'Uloženo', noteRequired:'Napište, co je potřeba změnit.', expires:'Platí do' },
-  en: { makePublicVersion:'Make version public', draft:'Draft', liveShared:'live, shared', publishHint:'Publish version saves the whole flow as %V; unchanged steps are reused.', htmlView:'HTML view', htmlViewNote:'A static copy of the page: no scripts of the site, styles and images rehosted, secrets removed.', editTitle:'Edit in the canvas', editText:'Text', editKeep:'keep', editSave:'Save edit', editSaved:'Edit saved as a new revision', editRebased:'The step changed meanwhile; the edit is on the latest revision', editUnapplied:'Not applied (the element no longer exists)', staleCapture:'The screenshot is from the previous revision; Live shows the latest edit.', branches:'Branches', mergeBranch:'Merge into main', mergeConflict:'Step changed on both branches:', mergeTakeBranch:'Take the branch version? (Cancel = keep main)', branchMerged:'Merged', acceptVersion:'Accept version', returnVersion:'Return version', versionVerdict:'Version verdict', draftInfo:'This draft is live and shared: everyone who has it open sees changes as they happen, agents’ changes too. kaloko sync and canvas edits save steps; Publish version saves the whole flow as a new version.', changedSince:'Changed since', noChangeSince:'No change since', designEnv:'design', version:'Version', versions:'Flow versions', publish:'Publish version', publishName:'Version name (optional)', published:'Published', designRef:'design reference', setDesignRef:'Set as design reference', unsetDesignRef:'Unset design reference', designRefHint:'Implementation is checked against the design reference (pack design).', openDraft:'Open the draft', liveMode:'Live', shotMode:'Screenshot', inspect:'Inspect', pinComment:'Comment on element', pickHint:'Click an element in the preview.', pinnedOn:'On element', unchangedSince:'unchanged since', unchangedSteps:'steps unchanged', changedOnly:'Changed only', stepStatus:'Step status', st_in_progress:'in progress', st_ready_for_review:'ready for review', st_ready_for_dev:'ready for dev', present:'Present', presenting:'You are presenting', stopPresent:'Stop presenting', updatedSteps:'updated', viaAgent:'via', here:'here', copyCss:'Copy CSS', cssCopied:'CSS copied', noToken:'outside the token set', tokenSet:'token', revisionBy:'revision', noLiveOrigin:'Live steps are not enabled on this instance.', draftEmpty:'The draft has no steps yet; run kaloko sync.', prototypeTo:'Prototype: go to', outdated:'outdated', prototype:'Prototype', protoTitle:'Present the prototype', protoHint:'Click through the prototype; ← → previous / next step, Esc to leave.', protoShot:'Screenshots only: live steps are not available here. ← → move through the flow.', protoLocal:'Links open the pages from disk; ← → move through the flow.', protoDevice:'Device frame', protoFull:'Full screen', protoExit:'Leave the prototype', protoNoStep:'The link does not lead to a step of the flow',     hint:'Drag to pan · Ctrl + wheel to zoom · <span class="kbd">F</span> focus mode · <span class="kbd">K</span> scenarios and runs · <span class="kbd">R</span> replay · <span class="kbd">P</span> prototype · <span class="kbd">I</span> map / index · <span class="kbd">←</span><span class="kbd">→</span> previous / next step (in the detail) · <span class="kbd">Esc</span> close', locale:'Tested locale', view:'View', both:'Both', shownRun:'Shown run', allRuns:'All runs', steps:'Flow steps', fit:'Fit flow', stepsWord:'steps', passedWord:'passed', fitLane:'Show the whole section', following:'Following', followEsc:'Esc to stop', followHint:'Follow what they do', visOn:'Others see me', visOff:'Hidden',
+  en: { makePublicVersion:'Make version public', draft:'Draft', liveShared:'live, shared', publishHint:'Publish version saves the whole flow as %V; unchanged steps are reused.', htmlView:'HTML view', htmlViewNote:'A static copy of the page: the site’s scripts removed, styles and images rehosted, secrets stripped.', editTitle:'Edit in the canvas', editText:'Text', editKeep:'keep', editSave:'Save edit', editSaved:'Edit saved as a new revision', editRebased:'The step changed meanwhile; the edit is on the latest revision', editUnapplied:'Not applied (the element no longer exists)', staleCapture:'The screenshot is from the previous revision; Live shows the latest edit.', branches:'Branches', mergeBranch:'Merge into main', mergeConflict:'Step changed on both branches:', mergeTakeBranch:'Take the branch version? (Cancel = keep main)', branchMerged:'Merged', acceptVersion:'Accept version', returnVersion:'Return version', versionVerdict:'Version verdict', draftInfo:'This draft is live and shared: everyone who has it open sees changes as they happen, including the agents’. kaloko sync and canvas edits save steps; Publish version saves the whole flow as a new version.', changedSince:'Changed since', noChangeSince:'No change since', designEnv:'design', version:'Version', versions:'Flow versions', publish:'Publish version', publishName:'Version name (optional)', published:'Published', designRef:'design reference', setDesignRef:'Set as design reference', unsetDesignRef:'Unset design reference', designRefHint:'Implementation is checked against the design reference (pack design).', openDraft:'Open the draft', liveMode:'Live', shotMode:'Screenshot', inspect:'Inspect', pinComment:'Comment on element', pickHint:'Click an element in the preview.', pinnedOn:'On element', unchangedSince:'unchanged since', unchangedSteps:'steps unchanged', changedOnly:'Changed only', stepStatus:'Step status', st_in_progress:'in progress', st_ready_for_review:'ready for review', st_ready_for_dev:'ready for dev', present:'Present', presenting:'You are presenting', stopPresent:'Stop presenting', updatedSteps:'updated', viaAgent:'via', here:'here', copyCss:'Copy CSS', cssCopied:'CSS copied', noToken:'outside the token set', tokenSet:'token', revisionBy:'revision', noLiveOrigin:'Live steps are not enabled on this instance.', draftEmpty:'The draft has no steps yet; run kaloko sync.', prototypeTo:'Prototype: go to', outdated:'outdated', prototype:'Prototype', protoTitle:'Present the prototype', protoHint:'Click through the prototype; ← → previous / next step, Esc to leave.', protoShot:'Screenshots only: live steps are not available here. ← → move through the flow.', protoLocal:'Links open the pages from disk; ← → move through the flow.', protoDevice:'Device frame', protoFull:'Full screen', protoExit:'Leave the prototype', protoNoStep:'The link does not lead to a step of the flow',     hint:'Drag to pan · Ctrl + wheel to zoom · <span class="kbd">F</span> focus mode · <span class="kbd">K</span> scenarios and runs · <span class="kbd">R</span> replay · <span class="kbd">P</span> prototype · <span class="kbd">I</span> map / index · <span class="kbd">←</span><span class="kbd">→</span> previous / next step (in the detail) · <span class="kbd">Esc</span> close', locale:'Tested locale', view:'View', both:'Both', shownRun:'Shown run', allRuns:'All runs', steps:'Flow steps', fit:'Fit flow', stepsWord:'steps', passedWord:'passed', fitLane:'Show the whole section', following:'Following', followEsc:'Esc to stop', followHint:'Follow what they do', visOn:'Others see me', visOff:'Hidden',
     pass:'Passed', partial:'Partial', fail:'Failed', skip:'Not checked', crop:'crop', html:'HTML snapshot', email:'e-mail', external:'third party',
     branch:'Branch', commit:'Commit', author:'Author', pr:'PR', issue:'Issue', env:'Environment', duration:'Duration', noPr:'no PR', open:'open', merged:'merged', closed:'closed',
     older:'Older run', newer:'Newer run', purpose:'Screen purpose from the scenario', criteria:'Acceptance criteria', jevTitle:'Semantic evaluation',
-    jevNote:'The evaluator received the reduced page state and returned a probability per question. The runner adds verdicts by threshold and evidence.', evalLabel:'Evaluation', metaTitle:'Page metadata', mdBasic:'Basics', mdHeadings:'Heading outline', mdHreflang:'Language versions (hreflang)', mdOg:'Open Graph', mdTwitter:'Twitter / X', mdLd:'Structured data · JSON-LD', mdMicro:'Structured data · microdata', mdLinks:'Other head links', mdOther:'Other meta', missing:'Missing', duplicate:'duplicate', size:'Size', runVerdict:'Run verdict', accept:'Accept run', ret:'Return run', pending:'pending', accepted:'accepted', returned:'returned', baseline:'Baseline run', setBaseline:'Set as baseline', unsetBaseline:'Unset baseline', verdictNotePh:'Verdict note (required when returning)', manualPass:'Pass', manualFail:'Fail', manualNotePh:'Reason (required for fail)', reviewerVerdict:'reviewer verdict', decideManual:'Decide manually', consoleErrors:'Console errors', consoleLoading:'Loading the messages…', noConsole:'No console messages were kept for this capture.', consoleMore:(n) => `${n} more not stored (the first 20 are kept).`, blockedTitle:'Blocked requests', copyAll:'Copy all', copyOne:'Copy this message', copied:'Copied', tabOverview:'Criteria', tabPage:'Page', tabTech:'Technical', toSolve:(n) => `${n} to solve`, passedN:(n) => `${n} passed`, whyMatters:'Why it matters:', howFix:'How to fix:', whyAndFix:'Why it matters and how to fix it', aiShort:(p) => `AI ${p} % yes`, noneFailed:'Nothing failed.', toDecide:'For a person to decide', toDecideLead:'The AI was unsure or could not evaluate; open the step, look at the screenshot and decide.', worthLook:'Worth a look', jevScoreHint:'Average confidence of the AI that the semantic criteria of this screen are met', sigTitle:'Quick signals', sigLead:'Asked by the AI beside the criteria on every screen. They do not change the result; they point at screens worth a look.', sigPurpose:'Does what the step is for', sigLanguage:'Text in the expected language', sigBroken:'Looks broken (error, placeholder, blank)', sigWarn:(n) => `${n} signal(s) worth a look`, sigYes:(p) => `${p} % yes`,
+    jevNote:'The evaluator got a reduced page state and returned a probability for each question. The runner turned them into verdicts by threshold and added the evidence.', evalLabel:'Evaluation', metaTitle:'Page metadata', mdBasic:'Basics', mdHeadings:'Heading outline', mdHreflang:'Language versions (hreflang)', mdOg:'Open Graph', mdTwitter:'Twitter / X', mdLd:'Structured data · JSON-LD', mdMicro:'Structured data · microdata', mdLinks:'Other head links', mdOther:'Other meta', missing:'Missing', duplicate:'duplicate', size:'Size', runVerdict:'Run verdict', accept:'Accept run', ret:'Return run', pending:'pending', accepted:'accepted', returned:'returned', baseline:'Baseline run', setBaseline:'Set as baseline', unsetBaseline:'Unset baseline', verdictNotePh:'Verdict note (required when returning)', manualPass:'Pass', manualFail:'Fail', manualNotePh:'Reason (required for fail)', reviewerVerdict:'reviewer verdict', decideManual:'Decide manually', consoleErrors:'Console errors', consoleLoading:'Loading the messages…', noConsole:'No console messages were kept for this capture.', consoleMore:(n) => `${n} more not stored (the first 20 are kept).`, blockedTitle:'Blocked requests', copyAll:'Copy all', copyOne:'Copy this message', copied:'Copied', tabOverview:'Criteria', tabPage:'Page', tabTech:'Technical', toSolve:(n) => `${n} to solve`, passedN:(n) => `${n} passed`, whyMatters:'Why it matters:', howFix:'How to fix:', whyAndFix:'Why it matters and how to fix it', aiShort:(p) => `AI ${p} % yes`, noneFailed:'Nothing failed.', toDecide:'For a person to decide', toDecideLead:'The AI was unsure or could not evaluate; open the step, look at the screenshot and decide.', worthLook:'Worth a look', jevScoreHint:'Average confidence of the AI that the semantic criteria of this screen are met', sigTitle:'Quick signals', sigLead:'The AI asks these on every screen next to the criteria. They never change the result, only point at screens worth a look.', sigPurpose:'Does what the step is for', sigLanguage:'Text in the expected language', sigBroken:'Looks broken (error, placeholder, blank)', sigWarn:(n) => `${n} signal(s) worth a look`, sigYes:(p) => `${p} % yes`,
     howAuto:'Automatic check', howAi:'AI evaluation', howManual:'Decided by a person', howTech:'Technical detail',
     aiPass:(p, t) => `The evaluator is ${p} % sure the answer is yes; passes from ${t} %.`, aiFail:(p, t) => `Only ${p} % yes; fails at ${t} % or less.`, aiUnsure:(p, lo, hi) => `Unsure: ${p} % yes, between ${lo} % and ${hi} %. Look at the screenshot and decide below.`,
     aiNotEval:'Not evaluated yet.', aiVia:{ qawalk:'evaluated by Kaloko', 'own-key':'evaluated with your key' }, aiAsked:'Asked',
     a_exists:(s) => `${s} is on the page`, a_absent:(s) => `${s} is not on the page`, a_count:(s, mn, mx) => `${s} appears ${mn != null && mn === mx ? `exactly ${mn}×` : mn != null && mx != null ? `${mn}–${mx}×` : mn != null ? `at least ${mn}×` : mx != null ? `at most ${mx}×` : ''}`, a_text_matches:(s, p) => `${s || 'The page'} contains ${p}`, a_text_absent:(s, p) => `${s || 'The page'} does not contain ${p}`, a_attr_equals:(s, a, v) => `${s} has ${a} = ${v}`,
-    a_no_overflow:'Nothing overflows the screen width', a_no_console_errors:'No errors in the browser console', a_title_matches:(p) => `The page title matches ${p}`, a_meta_matches:(s, p) => `Page metadata ${s} matches ${p}`, a_link_matches:(s) => `Links ${s} point where they should`, a_http_status:(v) => `The server answers ${v || '2xx'}`, a_link_home:'The page links back home',
+    a_no_overflow:'Nothing overflows the screen width', a_no_console_errors:'No errors in the browser console', a_title_matches:(p) => `The page title matches ${p}`, a_meta_matches:(s, p) => `Page metadata ${s} matches ${p}`, a_link_matches:(s) => `Links ${s} point where they should`, a_http_status:(v) => `The server answers ${v || '2xx'}`, a_link_home:'The page links back home', a_links_ok:'Internal links work (no 404)', a_hreflang_pairs:'Language versions (hreflang) link to each other',
     a_perf_lcp:(mx) => `Largest content appears within ${mx} ms`, a_perf_cls:'Layout stays stable while loading', a_perf_ttfb:(mx) => `The server starts answering within ${mx} ms`, a_perf_weight:'The page is light enough to load quickly',
     a_a11y:'Accessibility rule', a_design:'Matches the design reference', a_uses_tokens:'Colors, fonts and sizes come from the token set', a_app:'App rule', files:'files', storage:'Storage', copyLink:'Copy link', linkCopied:'Link copied', noPlaceToast:'This criterion has no location on the page or in the metadata; the evidence is in the criterion text.', noMeta:'This run is older and did not collect page metadata. Start a new run.', noBoxToast:'The element was not found in this capture.', onPage:'on the page', inMeta:'in metadata', inConsole:'in the console', noPlace:'no location on the page', clickHl:'Click a criterion to highlight it on the page or in the metadata',  invalidJson:'invalid JSON', attachments:'Step attachments', tech:'Technical details',
     execution:'Step execution', step:'Step', of:'of', hover:'Click a criterion to highlight it on the page or in the metadata', fullPage:'full page',
@@ -1843,7 +1843,7 @@ function renderChrome () {
   const app = window.QAWALK_APP;
   $('brand').href = app ? (app.user ? `/${app.org}/` : '/') : '#';
   $('appNav').innerHTML = (app && app.user ? `<a href="/${esc(app.org)}/projects">${UI === 'cs' ? 'Projekty' : 'Projects'}</a><a href="/${esc(app.org)}/">${UI === 'cs' ? 'Scénáře' : 'Scenarios'}</a><a href="/${esc(app.org)}/runs" aria-current="page">${UI === 'cs' ? 'Běhy' : 'Runs'}</a>` : app ? (app.embed ? `<a href="${esc(location.pathname)}" target="_blank" rel="noopener">${T('openInApp')} ↗</a>` : `<a href="/login">${T('signInLink')}</a>`) : '')
-    + `<span class="langsw">${['cs', 'en'].map((l) => `<button type="button" data-lang="${l}" aria-pressed="${l === UI}">${l.toUpperCase()}</button>`).join('')}</span>`;
+    + `<span class="langsw">${['en', 'cs'].map((l) => `<button type="button" data-lang="${l}" aria-pressed="${l === UI}">${l.toUpperCase()}</button>`).join('')}</span>`;
   $('appNav').querySelectorAll('[data-lang]').forEach((b) => { b.onclick = () => { if (b.dataset.lang !== UI) switchLang(b.dataset.lang); }; });
   document.querySelectorAll('[data-t]').forEach((el) => { el.textContent = T(el.dataset.t); });
   $('helpBtn').title = `${T('helpTitle')} (?)`; $('helpBtn').setAttribute('aria-label', T('helpTitle'));
@@ -2472,6 +2472,25 @@ function liveSrc (cap, bases = RUN.live_bases) {
   const b = bases?.[l.revision];
   return b ? b + l.entry : null;
 }
+/**
+ * A page inside a step's live folder that a prototype link named (frame.js sends `path`, e.g. "step-b/details.html"):
+ * only inside that step's own folder, no "..", no absolute or scheme paths; null otherwise (the step's entry opens).
+ */
+function livePath (path, node) {
+  if (typeof path !== 'string' || typeof node !== 'string' || path.length > 240 || !path.startsWith(node + '/')) return null;
+  const parts = path.split('/');
+  if (parts.some((x) => !x || x === '.' || x === '..' || /[\\:\u0000-\u001f]/.test(x))) return null;
+  return parts.map(encodeURIComponent).join('/');
+}
+/** liveSrc with the step's entry replaced by `path` (from livePath), within the same revision. */
+function liveSubSrc (cap, path, bases) {
+  const src = liveSrc(cap, bases); const entry = cap?.live?.entry;
+  if (!src || !path || !entry) return src;
+  const enc = entry.split('/').map(encodeURIComponent).join('/');
+  if (src.endsWith(entry)) return src.slice(0, src.length - entry.length) + path;
+  if (src.endsWith(enc)) return src.slice(0, src.length - enc.length) + path;
+  return src;
+}
 function viewSrc (cap, bases = RUN.live_bases) {
   const l = cap?.view; if (!l?.revision) return null;
   if (!APP()) return `live/${l.revision}/${l.entry}`;
@@ -2596,12 +2615,17 @@ addEventListener('message', (e) => {
   // presenting: the frame moves between steps (links, data-kaloko-go) and hands over the keys it does not use
   if (!$('pt').hidden) {
     const str = (x) => typeof x === 'string' ? x.slice(0, 300).replace(/[#\s]/g, '') : '';
-    if (m.type === 'qawalk:go' && typeof m.node === 'string') { if (byId(m.node) && byId(m.node).kind !== 'decision') ptOpen(m.node, PT.vp, { query: str(m.query), hash: str(m.hash) }); else toast(T('protoNoStep')); }
+    if (m.type === 'qawalk:go' && typeof m.node === 'string') { if (byId(m.node) && byId(m.node).kind !== 'decision') ptOpen(m.node, PT.vp, { query: str(m.query), hash: str(m.hash), path: livePath(m.path, m.node) }); else toast(T('protoNoStep')); }
     if (m.type === 'qawalk:key') ptKey({ key: String(m.key), preventDefault () {} });
     return;
   }
   if (m.type === 'qawalk:ready' && n) { toFrame({ type: 'qawalk:pins', pins: pinsFor(n, S.lbVp) }); if (LIVE.mode) toFrame({ type: 'qawalk:mode', mode: LIVE.mode }); }
-  if (m.type === 'qawalk:go' && typeof m.node === 'string' && byId(m.node)) { toast(`${T('prototypeTo')} ${loc(byId(m.node).title)}`); openLb(m.node, S.lbVp); }
+  if (m.type === 'qawalk:go' && typeof m.node === 'string' && byId(m.node)) {
+    toast(`${T('prototypeTo')} ${loc(byId(m.node).title)}`); openLb(m.node, S.lbVp);
+    // a link to a page inside the step's folder opens that page in the live frame, not the step's entry
+    const sub = livePath(m.path, m.node), fr = $('lbFrame'), c = byId(m.node).captures?.[S.loc]?.[S.lbVp];
+    if (sub && fr && S.lbMode === 'live') { const u = liveSubSrc(c, sub); if (u) fr.src = u; }
+  }
   if (m.type === 'qawalk:hover' && LIVE.mode === 'inspect' && m.el) { LIVE.insp = sanitizeEl(m.el); const sec = $('inspSec'); if (sec) sec.outerHTML = inspectorHtml(); else $('lbSideTop')?.insertAdjacentHTML('afterend', inspectorHtml()); wireCopyCss(); }
   if (m.type === 'qawalk:picked' && m.el) {
     const el = sanitizeEl(m.el);
@@ -2662,14 +2686,14 @@ function wireStepStatus (n) {
 
 
 // ---- prototype presentation (#42): full screen, live pages where the run has them, screenshots otherwise ----
-const PT = { id: null, vp: null, device: true, query: '', hash: '', from: null };
+const PT = { id: null, vp: null, device: true, query: '', hash: '', path: '', from: null };
 const ptList = () => flowOrder().filter((n) => n.kind !== 'decision' && n.kind !== 'stack' && !n.item);
 function ptOpen (id, vpName, extra = {}) {
   const list = ptList(); if (!list.length) return;
   const n = list.includes(byId(id)) ? byId(id) : list[0];
   if ($('pt').hidden) { PT.from = $('lb').hidden ? null : S.open; PT.device = innerWidth > 700; }
   $('lb').hidden = true; LIVE.mode = null;
-  PT.id = n.id; PT.query = extra.query || ''; PT.hash = extra.hash || '';
+  PT.id = n.id; PT.query = extra.query || ''; PT.hash = extra.hash || ''; PT.path = extra.path || '';
   PT.vp = viewports().some((v) => v.name === vpName) ? vpName : PT.vp || S.lbVp || (S.vp === 'mobile' ? mVp() : dVp())?.name || viewports()[0].name;
   renderPt();
   setHash({ present: n.id, loc: S.loc, vp: PT.vp });
@@ -2693,7 +2717,7 @@ function renderPt () {
   const el = $('pt'), list = ptList(), n = byId(PT.id), i = list.indexOf(n);
   const v = viewports().find((x) => x.name === PT.vp) || viewports()[0];
   const cap = n.captures?.[S.loc]?.[v.name];
-  const src = liveSrc(cap);
+  const src = PT.path ? liveSubSrc(cap, PT.path) : liveSrc(cap);
   const url = src ? src + (PT.query ? `?${PT.query}` : '') + (PT.hash ? `#${PT.hash}` : '') : null;
   const kind = v.mobile ? 'phone' : 'desk';
   const screen = url ? `<iframe id="ptIframe" title="${esc(loc(n.title))}" sandbox="allow-scripts allow-forms" referrerpolicy="no-referrer" src="${esc(url)}" style="width:${v.w}px;height:${v.h}px"></iframe>`