@agentwhy/cli 0.0.0-dev

package/dist/report/render/report-copy.js

@@ -0,0 +1,1177 @@
+import { APP_WORDS } from './ui/words/app-words.js';
+import { CONVERSATIONS_WORDS } from './ui/words/conversations-words.js';
+import { MONTH_WORDS } from './ui/words/month-words.js';
+import { ONBOARDING_WORDS } from './ui/words/onboarding-words.js';
+import { PROJECTS_WORDS } from './ui/words/projects-words.js';
+import { REPORT_WORDS } from './ui/words/report-words.js';
+import { SETTINGS_WORDS } from './ui/words/settings-words.js';
+import { TO_FIX_WORDS } from './ui/words/to-fix-words.js';
+export const LANGS = ['en', 'pl', 'de'];
+export const DEFAULT_LANG = 'en';
+export const LANG_NAMES = { en: 'English', pl: 'Polski', de: 'Deutsch' };
+/** English and German count one against the rest; Polish has a third form for 2–4, and not for 12–14. */
+function category(lang, count) {
+    if (count === 1)
+        return 'one';
+    if (lang !== 'pl')
+        return 'other';
+    const last = count % 10;
+    const lastTwo = count % 100;
+    return last >= 2 && last <= 4 && !(lastTwo >= 12 && lastTwo <= 14) ? 'few' : 'many';
+}
+/**
+ * Values arrive already escaped, because most of them are HTML fragments the caller built (`<code>` around a
+ * path, `<b>` around a tool). The dictionary itself is the project's own text, so it is written as HTML.
+ */
+function format(template, vars) {
+    return template.replace(/\{(\w+)\}/g, (whole, name) => (name in vars ? String(vars[name]) : whole));
+}
+export function translator(lang) {
+    const table = TABLES[lang];
+    return (key, vars = {}) => {
+        const count = typeof vars['n'] === 'number' ? vars['n'] : undefined;
+        const plural = count === undefined ? undefined : table[key + '.' + category(lang, count)];
+        const text = plural ?? table[key] ?? TABLES.en[key + (count === undefined ? '' : '.' + category('en', count))] ?? TABLES.en[key] ?? key;
+        return format(text, vars);
+    };
+}
+/** One inline fragment per language; the CSS shows the chosen one. Use `blocks` when the fragment has block content. */
+export function inLanguages(render) {
+    return LANGS.map((lang) => '<span class="i18n" lang="' + lang + '">' + render(translator(lang), lang) + '</span>').join('');
+}
+/**
+ * An attribute cannot hold three languages, so every language keeps its own and the script swaps them.
+ *
+ * What `render` returns lands between double quotes and is written as it came, so a caller passing a value
+ * through must escape it first - the same contract `format` above states, and the one that matters most here,
+ * because an attribute has no tag around it to make an unescaped quote look wrong. A deny rule read out of a
+ * project's settings file reached these quotes raw and closed them, which turned a pattern anyone can commit
+ * into attributes on the button. Escaping inside this function instead would be wrong: callers such as
+ * `html-session-graph.ts` build their value out of already-escaped parts and would have it escaped twice.
+ */
+export function labelAttributes(render) {
+    return LANGS.map((lang) => ' data-label-' + lang + '="' + render(translator(lang)) + '"').join('') +
+        ' aria-label="' + render(translator(DEFAULT_LANG)) + '"';
+}
+const EN = {
+    'quote.open': '\u201C', 'quote.close': '\u201D',
+    'lang.aria': 'Report language',
+    'bar.analysis': 'Session analysis',
+    'bar.session': 'session <code>{id}</code>',
+    'bar.agents.one': '{n} agent', 'bar.agents.other': '{n} agents',
+    'bar.actions.one': '{n} action', 'bar.actions.other': '{n} actions',
+    'bar.record': 'Record: {state}',
+    'bar.policy': "Analysis rule: {level}", 'bar.policyDefault': ' (default)',
+    'bar.unknowns': 'What we cannot tell',
+    // The rail: the same words on both pages, short because a collapsed rail shows them one icon wide.
+    'rail.nav': 'Sections of this page',
+    // The heading over the items, and the standing fact the sessions index carries in the same place.
+    // The three readings of one agent, where a script can offer them one at a time. Without one they are stacked.
+    'tab.summary': 'Summary', 'tab.steps': 'Step by step', 'tab.evidence': 'Evidence',
+    'tab.group': 'What this agent did',
+    'side.nav': 'Back to the session list',
+    'side.record': 'Session record',
+    'rail.sessions': 'Sessions',
+    'record.complete': 'complete', 'record.partial': 'partial', 'record.unresolved': 'part of the data could not be joined',
+    'files.one': '{n} protected file', 'files.other': '{n} protected files',
+    'verdict.appeared.one': 'appeared', 'verdict.appeared.other': 'appeared',
+    "verdict.result": "<em>Agents saw the names of sensitive files.</em>",
+    'verdict.them.one': 'it', 'verdict.them.other': 'them',
+    "verdict.mixed": "<em>Agents saw or used the names of sensitive files.</em>",
+    "verdict.named": "<em>Agents reached for sensitive files.</em>",
+    'verdict.were.one': 'was', 'verdict.were.other': 'were',
+    "verdict.blocked": "No agent got into a sensitive file — <em>{n} {attempts} blocked</em>.",
+    'verdict.attempts.one': 'attempt was', 'verdict.attempts.other': 'attempts were',
+    "verdict.signals": "<em>A result contains something that looks like a password or key.</em>",
+    "verdict.incomplete": "<em>We cannot tell</em> — part of the record is missing.",
+    "verdict.clear": "Nothing shows that agents saw sensitive files.",
+    "lead.incompleteCount.one": "Part of the record is missing: {n} action has no result.",
+    "lead.incompleteCount.other": "Part of the record is missing: {n} actions have no result.",
+    "lead.incomplete": "Part of the record is missing.",
+    'lead.noDelegations': 'The helper agents have no recorded instruction — their actions are here, what they were asked for is not.',
+    'lead.noGuarantee': 'That is not a guarantee that nothing was disclosed.',
+    "lead.hint": "Click an agent to see the details.",
+    "verdict.show": "Show:",
+    'filter.title': 'Click to show or hide',
+    "tier.hit.filter": "saw only a file name", "tier.hit.chip": "File name in a result", "tier.hit.row": "saw only the name",
+    "tier.hit.term": "<b>Saw only the name</b>: a result listed the file’s name. Its contents did not come back.",
+    "tier.secret.filter": "possible password or key", "tier.secret.chip": "Possible password or key", "tier.secret.row": "possible password or key",
+    "tier.secret.term": "<b>Possible password or key</b>: text that looks like one. It may be example data. The text is never shown here.",
+    "tier.named.filter": "file named in a command", "tier.named.chip": "File named in a command", "tier.named.row": "named in a command",
+    "tier.named.term": "<b>Named in a command</b>: a command mentioned the file, but its contents did not come back.",
+    "tier.unknown.filter": "record incomplete", "tier.unknown.chip": "Record incomplete", "tier.unknown.row": "record incomplete",
+    "tier.unknown.term": "<b>Record incomplete</b>: an action has no recorded result, so we cannot tell what happened.",
+    "tier.block.filter": "blocked", "tier.block.chip": "Blocked", "tier.block.row": "blocked",
+    "tier.block.term": "<b>Blocked</b>: the attempt was refused and returned nothing.",
+    "tier.clean.filter": "nothing found", "tier.clean.chip": "Nothing found", "tier.clean.row": "nothing found",
+    "tier.clean.term": "<b>Nothing found</b>: nothing in this agent’s record touched a sensitive file. Missing results can still hide something.",
+    "strip.hint": "Click an agent or a file.",
+    // The workbench, as `.ai/mocks/report-clean.html` lays it out: one panel holding the two views, and a panel of
+    // its own for what is selected. These are the page's own words for those parts.
+    'work.title': 'Who saw what',
+    'work.lead': 'Select an agent or a file to see what happened.',
+    'work.mapNote': 'Matching text can point to several files. It does not prove which file was opened.',
+    'work.tableAgent': 'Agent',
+    'work.shown': '{shown} of {total} agents shown',
+    'foot.local': 'Processed on your machine. No data sent.',
+    'foot.after': 'An analysis of a past session. It did not block anything.',
+    'view.aria': 'View', 'view.graph': 'Graph', 'view.list': 'List',
+    'col.you': 'You', 'col.main': 'Main agent', 'col.mainShort': 'Main',
+    'col.agents': 'Helper agents', 'col.agentsShort': 'Helpers',
+    "col.targets": "Sensitive files", 'col.targetsShort': 'Files',
+    'graph.aria': 'Session graph: who was asked for what, who did what, and what they touched',
+    'graph.you': 'You — where the session starts',
+    "graph.clean": "nothing found", 'graph.cleanSub': 'collapsed — click to see them', "graph.cleanAria": "Agents with nothing found",
+    'graph.gap': 'Delegation with no agent', 'graph.gapSub': 'no description recorded',
+    'graph.targetAgents.one': '{n} agent', 'graph.targetAgents.other': '{n} agents',
+    "legend.delegated": "gave a task", "legend.hit": "saw only a name", "legend.secret": "possible password",
+    "legend.named": "named in a command", "legend.unknown": "record incomplete", "legend.block": "blocked", "legend.unresolved": "who started it is unknown",
+    'list.aria': 'Session agents, worst first',
+    'list.more': 'Show <u><span data-count></span> agents that reached nothing</u>',
+    'list.mainTask': 'Runs the session and delegates', 'list.unknownTask': 'Instruction not established', 'list.noDescription': 'No description recorded',
+    'list.gapOut': 'agent not established',
+    'panel.back': 'Back to:&nbsp;',
+    'panel.agentSub.main': 'runs the session and delegates', 'panel.agentSub.helper': "helper agent",
+    'step.asked': 'What it was asked', 'step.did': 'What it did', "step.result": "What came of it",
+    "panel.next": "What to do", 'panel.what': 'What is this?', 'panel.evidence': "Task recorded at: {evidence}",
+    "asked.note": "The task as written in the session.",
+    'asked.main': 'The main agent works from your conversation. This report does not quote it.',
+    'asked.noDescription': 'The delegation is in the record, but without a description.',
+    'asked.unresolved': 'We do not know what this agent was asked — the call that started it is missing from the record.',
+    'did.none': 'No actions recorded. That does not confirm the agent did nothing.',
+    'did.noStories.one': '{n} action recorded. None of them touched a protected path.',
+    'did.noStories.other': '{n} actions recorded. None of them touched a protected path.',
+    'did.used': 'Used <b>{did}</b>. {note}',
+    'wrote.head.reasoning': "The agent’s note before this action",
+    'wrote.head.said': "The agent’s message before this action",
+    'wrote.covers.one': "These words preceded {n} action.",
+    'wrote.covers.other': "These words preceded {n} actions, not just this one.",
+    'wrote.none': "No earlier message was recorded for this action.",
+    'wrote.blank.one': "The earlier message was recorded without its text.",
+    'wrote.blank.other': "The earlier messages were recorded without their text ({n}).",
+    'wrote.carried': "The earlier text contained data matching {files}. We hide that text.",
+    'wrote.cut': 'Cut at the first {n} characters.',
+    'wrote.size': 'It wrote {n} characters before this call; this view does not show them.',
+    "result.link": "See this file →",
+    "result.signals": "A result contains something that looks like a password or key. The text is hidden.",
+    "result.signalsLink": "All possible passwords or keys →",
+    'result.clean': 'No contact with protected files was found. That does not confirm the whole session was safe.',
+    "return.value": "Its reply to the agent that gave it the task contained the same text as {files}.",
+    // What the record forces rather than what it shows: the agent that delegated holds text only this agent read,
+    // and a child's one channel to its parent is its reply. The reply itself is not in the record.
+    "return.crossed": "The same text as {files} reached the agent that gave it the task. Its reply is not in this record, so how it was worded cannot be shown.",
+    "return.path": "Its reply mentioned {files}, but not what is inside.",
+    "return.report.one": "No text from sensitive files was found in its reply ({length} characters).",
+    "return.report.other": "No text from sensitive files was found in its reply ({length} characters).",
+    "return.unknown": "Its reply is missing or unreadable.",
+    "return.awaited": "It ran in the background. Its reply is not in the record.",
+    "return.written": "It wrote the same text as {files} in its own messages.",
+    "use.file": "The same text as in {files} was saved to {targets}.",
+    "use.fileProtected": "The same text as in {files} was saved to the sensitive file {targets}.",
+    "use.command": "A command{programs} contained the same text as {files}.",
+    "use.commit": "A commit{programs} contained the same text as {files}.",
+    "use.delegation": "A task for another agent contained the same text as {files}.",
+    "use.said": "A message contained the same text as {files}.",
+    "use.reasoning": "The agent’s notes contained the same text as {files}.",
+    "use.call": "A tool call contained the same text as {files}.",
+    "use.source.none": "Earlier steps do not show where the agent got it.",
+    "use.file.same": "The text was saved to {targets}.",
+    "use.fileProtected.same": "The text was saved to the sensitive file {targets}.",
+    "use.command.same": "A command{programs} contained the text.",
+    "use.commit.same": "A commit{programs} contained the text.",
+    "use.delegation.same": "A task for another agent contained the text.",
+    "use.said.same": "A message contained the text.",
+    "use.reasoning.same": "The agent’s notes contained the text.",
+    "use.call.same": "A tool call contained the text.",
+    'flow.dialog': 'What happened, step by step',
+    'flow.close': 'Close',
+    "flow.kind.asked": "Got a task",
+    'flow.kind.reached.succeeded': 'Reached a protected file', "flow.kind.reached.blocked": "Was blocked", "flow.kind.reached.unknown": "Result unknown",
+    "flow.kind.carried": "Saw the same text in another file",
+    "flow.kind.used.file": "Saved the text to a file", "flow.kind.used.command": "Used the text in a command", "flow.kind.used.delegation": "Passed the text to another agent",
+    "flow.kind.used.said": "Wrote the text in a message", "flow.kind.used.reasoning": "Wrote the text in its notes", "flow.kind.used.call": "Put the text in a tool call",
+    "flow.kind.delegated": "Started another agent", "flow.kind.returned": "Replied",
+    "flow.kind.received": "Was handed the file’s contents",
+    "flow.asked": "{by} asked: {asked}",
+    'flow.askedBare': '{by} started it, and no description was recorded.',
+    "flow.reached.result": "{did} showed the name {files}, not what is inside.",
+    "flow.reached.input": "Ran {did} with {files}. The contents did not come back.",
+    "flow.reached.printed": "Ran {did} with {files}. We see what the command printed, not how much of it reached the AI.",
+    "flow.received": "Code it wrote passed it the same text as in {files}. The text came from that code, not from one of its actions.",
+    "flow.reached.blocked": "Tried {did} on {files}, and it was blocked.",
+    "flow.reached.unknown": "Ran {did} on {files}, but the result is missing.",
+    "flow.carried": "{did} showed the same text in {named}, which is not marked as sensitive.",
+    "flow.carriedBare": "{did} showed the same text. Which file it came from is not clear.",
+    "flow.after": "(The agent had seen this text in step {n}.)",
+    "flow.openOther": "Open steps: {name}",
+    'flow.someAgent': 'an agent this report does not hold',
+    "flow.records.one": "Where in the record", "flow.records.other": "Where in the record",
+    'tldr.valueWrittenOn': ' It wrote a value from a protected file into files that are not protected.',
+    // One call printed several protected files at once: the value came from one of them, and which is not recorded.
+    'files.or': ' or ',
+    'tldr.valueReturned': ' Its answer carried a value from a protected file to the agent that started it.',
+    'tldr.valueWritten': ' It wrote a value from a protected file in its own messages, which the session’s transcript keeps.',
+    'tldr.hit': '{name} used <b>{did}</b>. The path {path} appeared in the result, although the call never named it.',
+    'tldr.named': '{name} named {path} in a <b>{did}</b> call. The call ran; the record does not show whether the file’s content was in the result.',
+    'tldr.unknown': '{name} used <b>{did}</b> on {path}, but the record holds no certain outcome.',
+    'tldr.block': '{name} tried to reach {path} (<b>{did}</b>). The record confirms the refusal.',
+    'tldr.more.one': ' {n} event at protected paths in total.', 'tldr.more.other': ' {n} events at protected paths in total.',
+    'tldr.alsoSignals.one': ' {n} result also carries a signal of a possible secret.',
+    'tldr.alsoSignals.other': ' {n} results also carry signals of possible secrets.',
+    'tldr.onlySignals.one': '{name}: {n} tool result carries a signal of a possible secret. The values are hidden.',
+    'tldr.onlySignals.other': '{name}: {n} tool results carry signals of possible secrets. The values are hidden.',
+    'tldr.actions.one': '{name} performed {n} action. None of them touched a protected file.',
+    'tldr.actions.other': '{name} performed {n} actions. None of them touched a protected file.',
+    'tldr.noActions': 'The record holds no action of this agent at all.',
+    'tldr.unknownActions.one': ' {n} action has no certain outcome.', 'tldr.unknownActions.other': ' {n} actions have no certain outcome.',
+    "story.blocked": "This attempt was blocked.", "story.unknown": "An attempt is visible, but not its result.",
+    "story.result": "A result showed a sensitive file’s name.", "story.input": "A command mentioned a sensitive file and ran.",
+    "source.result": "The command did not ask for this file; its name showed up in the result.",
+    "source.input": "The file was named in the command.",
+    'story.occurrences.one': '{n} occurrence', 'story.occurrences.other': '{n} occurrences',
+    'story.evidence': 'Evidence: <code>{evidence}</code>', 'story.link': 'Link to event #{n}',
+    "agent.stories": "File events ({n})",
+    "agent.shapes": "Possible passwords or keys ({n})", 'agent.actions': 'All actions ({n})',
+    'missing.chip': 'No link established', 'missing.title': 'Delegation with no agent established', 'missing.sub': 'delegation {id}',
+    'missing.tldr': 'The delegation is visible, but we do not know which agent carried it out. We do not assign it anyone else’s actions.',
+    'missing.description': 'Recorded description', 'missing.none': 'No description recorded.',
+    "target.why": "Why it counts as sensitive",
+    "target.whyPatterns.one": "It matches the rule {patterns}.",
+    "target.whyPatterns.other": "It matches the rules {patterns}.",
+    "target.whyPolicy": "It matches this analysis’s rules.",
+    "target.whyNote": "That does not mean it really holds passwords.",
+    "target.who": "Who touched it ({n})",
+    "signal.title": "Possible passwords or keys", "signal.name": "Possible passwords or keys",
+    'signal.sub.one': '{n} result · values hidden', 'signal.sub.other': '{n} results · values hidden',
+    "signal.tldr.one": "{n} result contains something that looks like a password or key. The text is hidden.",
+    "signal.tldr.other": "{n} results contain something that looks like a password or key. The text is hidden.",
+    'signal.kinds': 'Kinds of signal', 'signal.who': 'Who saw it', 'signal.all': 'All signals and evidence ({n})',
+    'signal.results.one': '{n} result', 'signal.results.other': '{n} results',
+    'ty.chip': 'Where the session starts', 'ty.title': 'You',
+    'ty.tldr': 'The session began with your conversation with the main agent. The record holds {agents}, {delegations} and {actions}.',
+    'ty.delegations.one': '{n} delegation', 'ty.delegations.other': '{n} delegations',
+    'ty.next': 'What happened next',
+    'clean.title.one': '{n} agent reached nothing', 'clean.title.other': '{n} agents reached nothing',
+    'clean.sub': '{actions} in total',
+    'clean.tldr': 'These agents touched no protected path and saw no possible secret. On the graph they are collapsed into one node until the “nothing reached” filter is on.',
+    'clean.empty': 'This session has no helper agents without findings.', 'clean.who': 'Who they are',
+    'scope.chip': 'Policy and scope', 'scope.title': 'Which policy produced this report?',
+    'scope.sub': 'session <code>{id}</code> · record: {state}',
+    'scope.noRead': 'protected resources must not be read or searched.',
+    'scope.noDisclose': 'reading is allowed; values must not be disclosed.',
+    'scope.other': 'see the policy source below.',
+    'scope.origin': 'Where the policy came from',
+    'scope.patterns.one': '{n} protection pattern', 'scope.patterns.other': '{n} protection patterns',
+    'scope.exceptions.one': '{n} exception', 'scope.exceptions.other': '{n} exceptions',
+    'scope.counts': '{patterns} · {exceptions}. A path matching one is a signal to check, not a finished verdict of a breach.',
+    'scope.builtIn': '<b>This is the built-in default policy.</b> No policy file was supplied. The report does not reconstruct the protection that was active at the time.',
+    'scope.privacy': 'Privacy', 'scope.privacyText': 'The analysis is local and runs after the fact. Full prompts, commands and results never enter the report; paths, task descriptions and shortened identifiers are visible. Secret values are hidden before the file is written.',
+    // The session list as the mock draws it: three tabs over the table, one badge per row, a footer that pages.
+    // The shell of the index: the sidebar that navigates it, and the heading of each view.
+    'side.local': 'On your machine', 'side.localSub': 'Nothing is uploaded. Nothing is measured.',
+    // The chart over the session list: one bar per day of the chosen period, or per week where the range is long.
+    'index.notices.notify.chat,terminal': 'And the terminal',
+    'index.notices.notify.chat,os': 'And a notification',
+    'table.expand': 'Open this table full width', 'table.dialog': 'Table, full width', 'table.close': 'Close the table',
+    'scope.paths': 'How paths are shown',
+    'scope.pathsFull': 'Paths are shown as they were written, relative to the project root where they lie under it.',
+    'scope.pathsShared': '<b>This is a shared report.</b> Nothing above the project root appears in it. That reduces exposure; it does not anonymise — a path inside the repository still names what the repository names.',
+    'scope.root.known': 'The project root was read from the session, so paths under it are shown relative to it.',
+    'scope.root.absent': 'No project root was recorded, so paths are shown exactly as written.',
+    'scope.root.absentShared': 'No project root was recorded, so nothing can be placed inside the project: every path that says where it starts is shown as a category.',
+    'scope.root.ambiguousShared': 'The session recorded {n} working directories, so no single project root describes it and every path that says where it starts is shown as a category.',
+    'scope.root.ambiguous': 'The session recorded {n} working directories, so no single project root describes it.',
+    'scope.technical': 'Technical details',
+    'scope.ruleset': 'Redaction ruleset', 'scope.redactions': 'Hidden occurrences of values', 'scope.distinct': 'Distinct hidden values',
+    'scope.protected': 'Protected contents', 'scope.missingClasses': 'Scanner classes not implemented', 'scope.none': 'none',
+    'gaps.chipGaps': 'The record has gaps', 'gaps.chipClean': 'No gaps found', 'gaps.title': 'What cannot be established?',
+    'gaps.sub': 'record: {state}',
+    'gaps.tldr': 'We do not establish the agent’s intent, the full context of its instructions, or confirmed disclosure of a secret.',
+    'gaps.record': 'Gaps in the record', 'gaps.noneFound': 'No gaps were found in the structure of the supplied record.',
+    'gaps.unresolved': 'Agents with no established instruction ({n})', 'gaps.unresolvedNote': 'we do not know who started it',
+    'gaps.missing': 'Delegations with no established agent ({n})',
+    'gaps.howToRead': 'How to read the numbers',
+    'gaps.howToReadText': 'A path named inside a shell command counts as touched — some of those are mentions rather than openings.',
+    'gaps.unknownActions': 'Actions with no certain outcome ({n})',
+    'what.main': '<b>The main agent</b> is the assistant you talk to. It does some of the work itself and delegates the rest to helper agents.',
+    'what.agent': "<b>A helper agent</b> is an assistant given a task by another agent. Its reply can become part of the other agent’s conversation.",
+    'what.unresolved': '<b>No established link</b>: we do not know who started this agent. On the graph it hangs from the main agent by a dashed line — that is an annotation, not an established fact.',
+    "what.file": "<b>A sensitive file</b> matches this analysis’s rules, such as <code>.env</code>. That does not mean access was blocked or that it really holds passwords.",
+    "limit": "This report shows what the session record contains. It cannot tell what the agent intended, or whether data was shared outside this session.",
+    "next.hit": "Nothing urgent. Agents only saw the file’s name.",
+    "next.secret": "Check whether it is a real password or key. If it is, change it.",
+    "next.named": "Open an agent below to see what the command did.",
+    "next.unknown": "Open an agent below to see what is missing.",
+    "next.block": "Nothing to do. The block worked.",
+    "next.clean": "Nothing to do.",
+    'outcome.succeeded': 'Succeeded', 'outcome.blocked': 'Refused', 'outcome.unknown': 'No certain outcome',
+    'table.caption': 'The agent’s actions in the order its transcript recorded them',
+    'table.step': 'Step', 'table.tool': 'Tool', 'table.path': 'Protected path', 'table.outcome': 'Outcome', 'table.evidence': 'Evidence',
+    'table.notDetected': 'none detected', 'table.signal': 'Signal',
+    'table.empty': 'No actions recorded. That does not confirm the agent did nothing.',
+    'skip': 'Skip to the report',
+    'title': 'agentwhy — what happened in session {id}',
+    "flow.delegated.value": "Started {agent}. Its reply contained the same text as {files}.",
+    "flow.delegated.crossed": "Started {agent}. The same text as {files} came back from it; its reply is not in this record.",
+    "flow.returned.crossed": "The same text as {files} reached {agent}. Its reply is not in this record.",
+    "flow.delegated.path": "Started {agent}. Its reply mentioned {files}, but not what is inside.",
+    "flow.delegated.report": "Started {agent}. No text from sensitive files was found in its reply.",
+    "flow.delegated.unknown": "Started {agent}. Its reply could not be read.",
+    "flow.delegated.awaited": "Started {agent} in the background. Its reply is not in the record.",
+    "flow.returned.value": "Its reply to {agent} contained the same text as {files}.",
+    "flow.returned.path": "Its reply to {agent} mentioned {files}, but not what is inside.",
+    "flow.returned.report": "No text from sensitive files was found in its reply to {agent}.",
+    "flow.returned.unknown": "Its reply could not be read.",
+    "flow.returned.awaited": "It ran in the background. Its reply is not in the record.",
+    "flow.open": "Show step by step ({n})",
+    // The steps tab, as `.ai/mocks/report-clean.html` lays it out: a heading that counts them, a control that opens
+    // the whole run in a dialog, and the first few steps read in place.
+    'steps.how': 'How it happened',
+    'steps.count.one': '{n} step', 'steps.count.other': '{n} steps',
+    'steps.expand': 'Expand',
+    'steps.all': 'Show all {n} steps',
+    'steps.dialog': 'Step by step',
+    'evidence.title': 'What the answer is based on',
+    'evidence.lead': 'Grouped by action, with the records each one rests on kept beside it.',
+    "agent.evidence": "Details: task, files, evidence",
+    "wrote.open": "What it wrote just before",
+    "flow.kind.reached.value": "Saw the file’s contents",
+    "flow.kind.reached.path": "Saw a file name",
+    "flow.kind.reached.named": "Mentioned a file in a command",
+    "wrote.blank.few": "The earlier messages were recorded without their text ({n}).",
+    "wrote.blank.many": "The earlier messages were recorded without their text ({n}).",
+    "wrote.covers.few": "These words preceded {n} actions, not just this one.",
+    "wrote.covers.many": "These words preceded {n} actions, not just this one.",
+    "flow.reached.value": "{did} showed it the same text as in {files}.",
+    "return.report.few": "No text from sensitive files was found in its reply ({length} characters).",
+    "return.report.many": "No text from sensitive files was found in its reply ({length} characters).",
+    // plain-report: the answer first, in words a first-time reader needs no glossary for.
+    "verdict.seen.one": "An agent saw <em>what is inside a sensitive file.</em>",
+    "verdict.seen.other": "{n} agents saw <em>what is inside sensitive files.</em>",
+    "lead.seen.who": "Who: {agents}.",
+    "lead.seen.files": "Files: {files}.",
+    "lead.seen.passed": "Passed on to another agent by: {agents}.",
+    "lead.seen.saved": "Saved to files by: {agents}.",
+    "lead.seen.next": "If these files hold real passwords or keys, change them.",
+    // The counts beside the answer, as the sessions index writes them: a number, then what it counts.
+    'stat.keys.one': 'possible key', 'stat.keys.other': 'possible keys',
+    'stat.files.one': 'matching file', 'stat.files.other': 'matching files',
+    'strip.title': 'Who saw what',
+    "tier.value.filter": "saw file contents",
+    "tier.value.chip": "Saw file contents",
+    "tier.value.row": "saw the contents",
+    "tier.value.term": "<b>Saw the contents</b>: the same text as in this file ended up in the agent’s conversation.",
+    "legend.value": "saw contents",
+    "graph.seen.yes": "saw file contents",
+    "graph.seen.maybe": "possible password or key",
+    "graph.seen.path": "saw only a file name",
+    "graph.seen.named": "file named in a command",
+    "graph.seen.unknown": "record incomplete",
+    "graph.seen.blocked": "blocked",
+    "graph.passed": "passed it on",
+    "graph.saved": "saved to a file",
+    "seen.question": "Did this agent see what is inside a sensitive file?",
+    "seen.word.yes": "Yes",
+    "seen.word.maybe": "Possibly",
+    "seen.word.path": "No",
+    "seen.word.named": "Not that we can see",
+    "seen.word.unknown": "Unknown",
+    "seen.word.blocked": "No",
+    "seen.word.no": "No",
+    "seen.word.empty": "Unknown",
+    "seen.says.yes": "The same text as in {files} ended up in its conversation.",
+    "seen.says.yes.bare": "Text from a sensitive file ended up in its conversation.",
+    "seen.says.maybe": "It saw text that looks like a password or key. It may also be example data.",
+    "seen.says.path": "It saw only the name {files}, not what is inside.",
+    "seen.says.path.bare": "It saw only a sensitive file’s name, not what is inside.",
+    "seen.says.named": "A command mentioned {files}, but its contents did not come back.",
+    "seen.says.named.bare": "A command mentioned a sensitive file, but its contents did not come back.",
+    "seen.says.unknown": "Part of the record is missing, so we cannot tell.",
+    "seen.says.blocked": "It tried to reach {files}, and that was blocked.",
+    "seen.says.blocked.bare": "It tried to reach a sensitive file, and that was blocked.",
+    "seen.says.no": "Nothing shows that it touched a sensitive file.",
+    "seen.says.empty": "This agent’s actions were not recorded.",
+    "seen.row.passed": "Passed it to another agent",
+    "seen.row.saved": "Saved it to a file",
+    "seen.row.chat": "Wrote it in its messages",
+    "seen.row.command": "Used it in a command",
+    "yn.yes": "Yes",
+    "yn.no": "No",
+    "yn.unknown": "Unknown",
+    "seen.next.yes": "If that file holds real passwords or keys, change them.",
+    "seen.next.maybe": "Check whether it is a real password or key. If it is, change it.",
+    "seen.next.path": "Nothing urgent. The agent only knows that the file exists.",
+    "seen.next.named": "The details below show what the command did.",
+    "seen.next.unknown": "The details below show what is missing.",
+    "seen.next.blocked": "Nothing to do. The block worked.",
+    "seen.next.no": "Nothing to do.",
+    "seen.next.empty": "Check that agentwhy can read this agent’s record.",
+    "seen.chip.yes": "Saw file contents",
+    "seen.chip.maybe": "Possible password or key",
+    "seen.chip.path": "Saw only a file name",
+    "seen.chip.named": "File named in a command",
+    "seen.chip.unknown": "Record incomplete",
+    "seen.chip.blocked": "Blocked",
+    "seen.chip.no": "Nothing found",
+    "seen.chip.empty": "No record",
+    "seen.incomplete": "Part of the record is missing, so this answer may be incomplete.",
+    "seen.help": "How does agentwhy know?",
+    "seen.helpText": "A sensitive file is one that matches this analysis’s rules, such as <code>.env</code>. That does not mean access to it was blocked. agentwhy compares text: when the same text is in such a file and in an agent’s conversation, the agent saw that text. The text itself is never shown in this report.",
+    "target.notSeen": "Agents saw or used only its name. Its contents did not come back.",
+    "target.unknown": "Part of the record is missing, so we cannot tell whether an agent saw what is inside.",
+    "target.blocked": "Every attempt to reach it was blocked.",
+    "next.value": "If this file holds real passwords or keys, change them.",
+    "story.value": "The agent saw this file’s contents.",
+    "lead.notBack": "Their contents did not come back to the agents.",
+    "target.seen.one": "1 agent saw what is inside this file.",
+    "target.seen.other": "{n} agents saw what is inside this file.",
+    "target.seen.few": "{n} agents saw what is inside this file.",
+    "target.seen.many": "{n} agents saw what is inside this file.",
+    "lead.seen.more": "and {n} more",
+    "index.incomplete": "record incomplete",
+};
+const PL = {
+    'quote.open': '\u201E', 'quote.close': '\u201D',
+    'lang.aria': 'Język raportu',
+    'bar.analysis': 'Analiza sesji',
+    'bar.session': 'sesja <code>{id}</code>',
+    'bar.agents.one': '{n} agent', 'bar.agents.few': '{n} agenci', 'bar.agents.many': '{n} agentów',
+    'bar.actions.one': '{n} działanie', 'bar.actions.few': '{n} działania', 'bar.actions.many': '{n} działań',
+    'bar.record': 'Zapis: {state}',
+    'bar.policy': "Zasada analizy: {level}", 'bar.policyDefault': ' (domyślna)',
+    'bar.unknowns': 'Czego nie wiemy',
+    'rail.nav': 'Sekcje tej strony',
+    'tab.summary': 'Podsumowanie', 'tab.steps': 'Krok po kroku', 'tab.evidence': 'Dowody',
+    'tab.group': 'Co zrobił ten agent',
+    'side.nav': 'Powrót do listy sesji',
+    'side.record': 'Zapis sesji',
+    'rail.sessions': 'Sesje',
+    'record.complete': 'kompletny', 'record.partial': 'częściowy', 'record.unresolved': 'nie udało się powiązać części danych',
+    'files.one': '{n} chroniony plik', 'files.few': '{n} chronione pliki', 'files.many': '{n} chronionych plików',
+    "verdict.result": "<em>Agenci widzieli nazwy wrażliwych plików.</em>",
+    'verdict.them.one': 'go', 'verdict.them.few': 'ich', 'verdict.them.many': 'ich',
+    'verdict.appeared.one': 'pojawił się', 'verdict.appeared.few': 'pojawiły się', 'verdict.appeared.many': 'pojawiło się',
+    "verdict.mixed": "<em>Agenci widzieli lub używali nazw wrażliwych plików.</em>",
+    "verdict.named": "<em>Agenci sięgali po wrażliwe pliki.</em>",
+    'verdict.were.one': 'został wskazany', 'verdict.were.few': 'zostały wskazane', 'verdict.were.many': 'zostało wskazanych',
+    "verdict.blocked": "Żaden agent nie dostał się do wrażliwego pliku — <em>{n} {attempts}</em>.",
+    'verdict.attempts.one': 'próba została zablokowana', 'verdict.attempts.few': 'próby zostały zablokowane', 'verdict.attempts.many': 'prób zostało zablokowanych',
+    "verdict.signals": "<em>W wyniku jest coś, co wygląda na hasło lub klucz.</em>",
+    "verdict.incomplete": "<em>Nie wiadomo</em> — brakuje części zapisu.",
+    "verdict.clear": "Nic nie wskazuje, że agenci widzieli wrażliwe pliki.",
+    "lead.incompleteCount.one": "Brakuje części zapisu. Działania bez wyniku: {n}.",
+    "lead.incompleteCount.few": "Brakuje części zapisu. Działania bez wyniku: {n}.",
+    "lead.incompleteCount.many": "Brakuje części zapisu. Działania bez wyniku: {n}.",
+    "lead.incomplete": "Brakuje części zapisu.",
+    'lead.noDelegations': 'Brakuje zleceń dla agentów pomocniczych — widać ich działania, ale nie wiadomo, co im polecono.',
+    'lead.noGuarantee': 'To nie jest gwarancja braku ujawnienia danych.',
+    "lead.hint": "Kliknij agenta, aby zobaczyć szczegóły.",
+    "verdict.show": "Pokaż:",
+    'filter.title': 'Kliknij, żeby pokazać lub ukryć',
+    "tier.hit.filter": "widział tylko nazwę pliku", "tier.hit.chip": "Nazwa pliku w wyniku", "tier.hit.row": "widział tylko nazwę",
+    "tier.hit.term": "<b>Widział tylko nazwę</b>: wynik pokazał nazwę pliku. Jego zawartość nie wróciła.",
+    "tier.secret.filter": "możliwe hasło lub klucz", "tier.secret.chip": "Możliwe hasło lub klucz", "tier.secret.row": "możliwe hasło lub klucz",
+    "tier.secret.term": "<b>Możliwe hasło lub klucz</b>: tekst, który tak wygląda. Może to być przykład. Sam tekst nigdy nie jest tu pokazywany.",
+    "tier.named.filter": "nazwa pliku w poleceniu", "tier.named.chip": "Nazwa pliku w poleceniu", "tier.named.row": "nazwa w poleceniu",
+    "tier.named.term": "<b>Nazwa w poleceniu</b>: polecenie wspomniało plik, ale jego zawartość nie wróciła.",
+    "tier.unknown.filter": "niepełny zapis", "tier.unknown.chip": "Niepełny zapis", "tier.unknown.row": "niepełny zapis",
+    "tier.unknown.term": "<b>Niepełny zapis</b>: działanie nie ma zapisanego wyniku, więc nie wiadomo, co się stało.",
+    "tier.block.filter": "zablokowano", "tier.block.chip": "Zablokowano", "tier.block.row": "zablokowano",
+    "tier.block.term": "<b>Zablokowano</b>: próbę odrzucono i nic nie zwróciła.",
+    "tier.clean.filter": "nic nie znaleziono", "tier.clean.chip": "Nic nie znaleziono", "tier.clean.row": "nic nie znaleziono",
+    "tier.clean.term": "<b>Nic nie znaleziono</b>: w zapisie tego agenta nic nie dotyczyło wrażliwych plików. Brakujące wyniki mogą jednak coś ukrywać.",
+    "strip.hint": "Kliknij agenta lub plik.",
+    'work.title': 'Kto co zobaczył',
+    'work.lead': 'Wybierz agenta lub plik, aby zobaczyć, co się stało.',
+    'work.mapNote': 'Pasujący tekst może wskazywać na kilka plików. Nie dowodzi, który plik został otwarty.',
+    'work.tableAgent': 'Agent',
+    'work.shown': 'pokazano {shown} z {total} agentów',
+    'foot.local': 'Przetworzone na Twoim komputerze. Nic nie zostało wysłane.',
+    'foot.after': 'Analiza minionej sesji. Niczego nie zablokowała.',
+    'view.aria': 'Widok', 'view.graph': 'Graf', 'view.list': 'Lista',
+    'col.you': 'Ty', 'col.main': 'Główny agent', 'col.mainShort': 'Główny',
+    'col.agents': 'Agenci pomocniczy', 'col.agentsShort': 'Pomocnicy',
+    "col.targets": "Wrażliwe pliki", 'col.targetsShort': 'Pliki',
+    'graph.aria': 'Graf sesji: kto zlecił zadanie, kto co zrobił i czego dotknął',
+    'graph.you': 'Ty — tu zaczyna się sesja',
+    "graph.clean": "bez znalezisk", 'graph.cleanSub': 'zwinięci — kliknij, żeby zobaczyć', "graph.cleanAria": "Agenci, u których nic nie znaleziono",
+    'graph.gap': 'Zlecenie bez agenta', 'graph.gapSub': 'brak opisu zlecenia',
+    'graph.targetAgents.one': '{n} agent', 'graph.targetAgents.few': '{n} agenci', 'graph.targetAgents.many': '{n} agentów',
+    "legend.delegated": "zlecił zadanie", "legend.hit": "tylko nazwa", "legend.secret": "możliwe hasło",
+    "legend.named": "nazwa w poleceniu", "legend.unknown": "niepełny zapis", "legend.block": "zablokowano", "legend.unresolved": "nie wiadomo, kto go uruchomił",
+    'list.aria': 'Agenci sesji, najpoważniejsze na górze',
+    'list.more': 'Pokaż <u><span data-count></span> agentów bez trafień</u>',
+    'list.mainTask': 'Prowadzi sesję i rozdziela zadania', 'list.unknownTask': 'Zlecenie nieznane', 'list.noDescription': 'Bez opisu zlecenia',
+    'list.gapOut': 'nieustalony wykonawca',
+    'panel.back': 'Wróć do:&nbsp;',
+    'panel.agentSub.main': 'prowadzi sesję i rozdziela zadania', 'panel.agentSub.helper': "agent pomocniczy",
+    'step.asked': 'Co mu zlecono', 'step.did': 'Co zrobił', "step.result": "Co z tego wyszło",
+    "panel.next": "Co zrobić", 'panel.what': 'Co to jest?', 'panel.evidence': "Zapis zadania: {evidence}",
+    "asked.note": "Treść zadania z sesji.",
+    'asked.main': 'Główny agent działa na podstawie Twojej rozmowy. Raport nie cytuje jej treści.',
+    'asked.noDescription': 'Zlecenie jest w zapisie, ale bez opisu.',
+    'asked.unresolved': 'Nie znamy zlecenia tego agenta — w zapisie brakuje wywołania, które go uruchomiło.',
+    'did.none': 'Brak zapisanych działań. To nie potwierdza, że agent nic nie zrobił.',
+    'did.noStories.one': 'Zapisano {n} działanie. Żadne nie dotyczyło chronionych ścieżek.',
+    'did.noStories.few': 'Zapisano {n} działania. Żadne nie dotyczyło chronionych ścieżek.',
+    'did.noStories.many': 'Zapisano {n} działań. Żadne nie dotyczyło chronionych ścieżek.',
+    'did.used': 'Użył <b>{did}</b>. {note}',
+    'wrote.head.reasoning': "Notatka agenta przed tym działaniem",
+    'wrote.head.said': "Wiadomość agenta przed tym działaniem",
+    'wrote.covers.one': "Ta wypowiedź poprzedzała {n} działanie.",
+    'wrote.covers.few': "Ta wypowiedź poprzedzała {n} działania, nie tylko to jedno.",
+    'wrote.covers.many': "Ta wypowiedź poprzedzała {n} działań, nie tylko to jedno.",
+    'wrote.none': "Nie zapisano wcześniejszej wypowiedzi dla tego działania.",
+    'wrote.blank.one': "Wcześniejszą wypowiedź zapisano bez jej treści.",
+    'wrote.blank.few': "Wcześniejsze wypowiedzi zapisano bez ich treści ({n}).",
+    'wrote.blank.many': "Wcześniejsze wypowiedzi zapisano bez ich treści ({n}).",
+    'wrote.carried': "Wcześniejszy tekst zawierał dane występujące w {files}. Ukrywamy jego treść.",
+    'wrote.cut': 'Ucięte na pierwszych {n} znakach.',
+    'wrote.size': 'Napisał przed tym wywołaniem {n} znaków; ten widok ich nie pokazuje.',
+    "result.link": "Zobacz ten plik →",
+    "result.signals": "W wyniku jest coś, co wygląda na hasło lub klucz. Sam tekst jest ukryty.",
+    "result.signalsLink": "Wszystkie możliwe hasła i klucze →",
+    'result.clean': 'Nie wykryto kontaktu z chronionymi plikami. To nie potwierdza bezpieczeństwa całej sesji.',
+    "return.value": "Jego odpowiedź dla agenta, który zlecił zadanie, zawierała ten sam tekst, co {files}.",
+    "return.crossed": "Ten sam tekst, co {files}, dotarł do agenta, który zlecił zadanie. Jego odpowiedzi nie ma w tym zapisie, więc nie można pokazać, jak była sformułowana.",
+    "return.path": "Jego odpowiedź wspomniała {files}, bez zawartości.",
+    "return.report.one": "W jego odpowiedzi ({length} znaków) nie znaleziono tekstu z wrażliwych plików.",
+    "return.report.few": "W jego odpowiedzi ({length} znaków) nie znaleziono tekstu z wrażliwych plików.",
+    "return.report.many": "W jego odpowiedzi ({length} znaków) nie znaleziono tekstu z wrażliwych plików.",
+    "return.unknown": "Brakuje jego odpowiedzi albo nie da się jej odczytać.",
+    "return.awaited": "Działał w tle. Jego odpowiedzi nie ma w zapisie.",
+    "return.written": "W swoich wiadomościach napisał ten sam tekst, co {files}.",
+    "use.file": "Ten sam tekst, co w {files}, zapisano w {targets}.",
+    "use.fileProtected": "Ten sam tekst, co w {files}, zapisano we wrażliwym pliku {targets}.",
+    "use.command": "Polecenie{programs} zawierało ten sam tekst, co {files}.",
+    "use.commit": "Commit{programs} zawierał ten sam tekst, co {files}.",
+    "use.delegation": "Zadanie dla innego agenta zawierało ten sam tekst, co {files}.",
+    "use.said": "Wiadomość zawierała ten sam tekst, co {files}.",
+    "use.reasoning": "Notatki agenta zawierały ten sam tekst, co {files}.",
+    "use.call": "Wywołanie narzędzia zawierało ten sam tekst, co {files}.",
+    "use.source.none": "Wcześniejsze kroki nie pokazują, skąd agent go miał.",
+    "use.file.same": "Tekst zapisano w {targets}.",
+    "use.fileProtected.same": "Tekst zapisano we wrażliwym pliku {targets}.",
+    "use.command.same": "Polecenie{programs} zawierało ten tekst.",
+    "use.commit.same": "Commit{programs} zawierał ten tekst.",
+    "use.delegation.same": "Zadanie dla innego agenta zawierało ten tekst.",
+    "use.said.same": "Wiadomość zawierała ten tekst.",
+    "use.reasoning.same": "Notatki agenta zawierały ten tekst.",
+    "use.call.same": "Wywołanie narzędzia zawierało ten tekst.",
+    'flow.dialog': 'Co się stało, krok po kroku',
+    'flow.close': 'Zamknij',
+    "flow.kind.asked": "Dostał zadanie",
+    'flow.kind.reached.succeeded': 'Dotarł do chronionego pliku', "flow.kind.reached.blocked": "Zablokowano", "flow.kind.reached.unknown": "Wynik nieznany",
+    "flow.kind.carried": "Zobaczył ten sam tekst w innym pliku",
+    "flow.kind.used.file": "Zapisał ten tekst w pliku", "flow.kind.used.command": "Użył tego tekstu w poleceniu", "flow.kind.used.delegation": "Przekazał ten tekst innemu agentowi",
+    "flow.kind.used.said": "Napisał ten tekst w wiadomości", "flow.kind.used.reasoning": "Napisał ten tekst w swoich notatkach", "flow.kind.used.call": "Wpisał ten tekst do narzędzia",
+    "flow.kind.delegated": "Uruchomił innego agenta", "flow.kind.returned": "Odpowiedział",
+    "flow.kind.received": "Dostał zawartość pliku",
+    "flow.asked": "{by} poprosił: {asked}",
+    'flow.askedBare': '{by} go uruchomił, a opisu nie zapisano.',
+    "flow.reached.result": "{did} pokazał nazwę {files}, bez zawartości.",
+    "flow.reached.input": "Uruchomił {did} z {files}. Zawartość nie wróciła.",
+    "flow.reached.printed": "Uruchomił {did} z {files}. Widać, co wypisało polecenie, ale nie to, ile z tego dotarło do AI.",
+    "flow.received": "Kod, który napisał, przekazał mu ten sam tekst, co w {files}. Tekst przyszedł z tego kodu, a nie z żadnego z jego działań.",
+    "flow.reached.blocked": "Próbował {did} na {files}, ale to zablokowano.",
+    "flow.reached.unknown": "Uruchomił {did} na {files}, ale brakuje wyniku.",
+    "flow.carried": "{did} pokazał ten sam tekst w {named}, który nie jest oznaczony jako wrażliwy.",
+    "flow.carriedBare": "{did} pokazał ten sam tekst. Nie wiadomo, z którego pliku.",
+    "flow.after": "(Agent widział ten tekst w kroku {n}.)",
+    "flow.openOther": "Otwórz kroki: {name}",
+    'flow.someAgent': 'agent, którego ten raport nie zawiera',
+    "flow.records.one": "Gdzie w zapisie", "flow.records.few": "Gdzie w zapisie", "flow.records.many": "Gdzie w zapisie",
+    'tldr.valueWrittenOn': ' Zapisał wartość z chronionego pliku w plikach, które nie są chronione.',
+    'files.or': ' lub ',
+    'tldr.valueReturned': ' Jego odpowiedź zawierała wartość z chronionego pliku i trafiła do agenta, który go uruchomił.',
+    'tldr.valueWritten': ' Napisał wartość z chronionego pliku w swoich wiadomościach, które przechowuje transkrypt sesji.',
+    'tldr.hit': '{name} użył <b>{did}</b>. Ścieżka {path} pojawiła się w wyniku, choć wywołanie jej nie wskazywało.',
+    'tldr.named': '{name} wskazał {path} w wywołaniu <b>{did}</b>. Operacja się wykonała; zapis nie pokazuje, czy treść pliku była w wyniku.',
+    'tldr.unknown': '{name} użył <b>{did}</b> przy {path}, ale zapis nie zawiera pewnego wyniku.',
+    'tldr.block': '{name} próbował sięgnąć po {path} (<b>{did}</b>). Zapis potwierdza odmowę.',
+    'tldr.more.one': ' Łącznie {n} zdarzenie przy chronionych ścieżkach.', 'tldr.more.few': ' Łącznie {n} zdarzenia przy chronionych ścieżkach.',
+    'tldr.more.many': ' Łącznie {n} zdarzeń przy chronionych ścieżkach.',
+    'tldr.alsoSignals.one': ' W {n} wyniku wykryto też możliwy sekret.', 'tldr.alsoSignals.few': ' W {n} wynikach wykryto też możliwe sekrety.',
+    'tldr.alsoSignals.many': ' W {n} wynikach wykryto też możliwe sekrety.',
+    'tldr.onlySignals.one': '{name}: w {n} wyniku narzędzi wykryto możliwy sekret. Wartości są ukryte.',
+    'tldr.onlySignals.few': '{name}: w {n} wynikach narzędzi wykryto możliwe sekrety. Wartości są ukryte.',
+    'tldr.onlySignals.many': '{name}: w {n} wynikach narzędzi wykryto możliwe sekrety. Wartości są ukryte.',
+    'tldr.actions.one': '{name} wykonał {n} działanie. Żadne nie dotyczyło chronionych plików.',
+    'tldr.actions.few': '{name} wykonał {n} działania. Żadne nie dotyczyło chronionych plików.',
+    'tldr.actions.many': '{name} wykonał {n} działań. Żadne nie dotyczyło chronionych plików.',
+    'tldr.noActions': 'W zapisie nie ma żadnego działania tego agenta.',
+    'tldr.unknownActions.one': ' {n} działanie nie ma pewnego wyniku.', 'tldr.unknownActions.few': ' {n} działania nie mają pewnego wyniku.',
+    'tldr.unknownActions.many': ' {n} działań nie ma pewnego wyniku.',
+    "story.blocked": "Tę próbę zablokowano.", "story.unknown": "Widać próbę, ale nie jej wynik.",
+    "story.result": "Wynik pokazał nazwę wrażliwego pliku.", "story.input": "Polecenie wspomniało wrażliwy plik i zostało wykonane.",
+    "source.result": "Polecenie nie wskazywało tego pliku; jego nazwa pojawiła się w wyniku.",
+    "source.input": "Plik był wymieniony w poleceniu.",
+    'story.occurrences.one': '{n} wystąpienie', 'story.occurrences.few': '{n} wystąpienia', 'story.occurrences.many': '{n} wystąpień',
+    'story.evidence': 'Dowód: <code>{evidence}</code>', 'story.link': 'Link do zdarzenia #{n}',
+    "agent.stories": "Zdarzenia z plikami ({n})",
+    "agent.shapes": "Możliwe hasła lub klucze ({n})", 'agent.actions': 'Wszystkie działania ({n})',
+    'missing.chip': 'Brak powiązania', 'missing.title': 'Zlecenie bez ustalonego agenta', 'missing.sub': 'zlecenie {id}',
+    'missing.tldr': 'Widać zlecenie, ale nie wiemy, który agent je wykonał. Nie przypisujemy mu cudzych działań.',
+    'missing.description': 'Zapisany opis zlecenia', 'missing.none': 'Brak opisu zlecenia.',
+    "target.why": "Dlaczego to wrażliwy plik",
+    "target.whyPatterns.one": "Pasuje do reguły {patterns}.",
+    "target.whyPatterns.few": "Pasuje do reguł {patterns}.",
+    "target.whyPatterns.many": "Pasuje do reguł {patterns}.",
+    "target.whyPolicy": "Pasuje do reguł tej analizy.",
+    "target.whyNote": "To nie znaczy, że na pewno zawiera hasła.",
+    "target.who": "Kto miał z nim styczność ({n})",
+    "signal.title": "Możliwe hasła lub klucze", "signal.name": "Możliwe hasła lub klucze",
+    'signal.sub.one': '{n} wynik · wartości ukryte', 'signal.sub.few': '{n} wyniki · wartości ukryte', 'signal.sub.many': '{n} wyników · wartości ukryte',
+    "signal.tldr.one": "Wyniki, które wyglądają na hasło lub klucz: {n}. Sam tekst jest ukryty.",
+    "signal.tldr.few": "Wyniki, które wyglądają na hasło lub klucz: {n}. Sam tekst jest ukryty.",
+    "signal.tldr.many": "Wyniki, które wyglądają na hasło lub klucz: {n}. Sam tekst jest ukryty.",
+    'signal.kinds': 'Rodzaje sygnałów', 'signal.who': 'Kto to zobaczył', 'signal.all': 'Wszystkie sygnały i dowody ({n})',
+    'signal.results.one': '{n} wynik', 'signal.results.few': '{n} wyniki', 'signal.results.many': '{n} wyników',
+    'ty.chip': 'Początek sesji', 'ty.title': 'Ty',
+    'ty.tldr': 'Sesja zaczęła się od Twojej rozmowy z głównym agentem. W zapisie jest {agents}, {delegations} i {actions}.',
+    'ty.delegations.one': '{n} zlecenie', 'ty.delegations.few': '{n} zlecenia', 'ty.delegations.many': '{n} zleceń',
+    'ty.next': 'Co było dalej',
+    'clean.title.one': '{n} agent bez trafień', 'clean.title.few': '{n} agenci bez trafień', 'clean.title.many': '{n} agentów bez trafień',
+    'clean.sub': 'razem {actions}',
+    'clean.tldr': 'Ci agenci nie dotknęli żadnej chronionej ścieżki ani możliwego sekretu. Na grafie są zwinięci w jeden element, dopóki nie włączysz filtra „bez trafień”.',
+    'clean.empty': 'W tej sesji nie ma agentów pomocniczych bez trafień.', 'clean.who': 'Kto to jest',
+    'scope.chip': 'Zasada i zakres', 'scope.title': 'Według jakiej zasady powstał raport?',
+    'scope.sub': 'sesja <code>{id}</code> · zapis: {state}',
+    'scope.noRead': 'chronionych zasobów nie wolno odczytywać ani przeszukiwać.',
+    'scope.noDisclose': 'odczyt jest dozwolony; nie wolno ujawniać wartości.',
+    'scope.other': 'sprawdź źródło zasady poniżej.',
+    'scope.origin': 'Źródło zasady',
+    'scope.patterns.one': '{n} wzorzec ochrony', 'scope.patterns.few': '{n} wzorce ochrony', 'scope.patterns.many': '{n} wzorców ochrony',
+    'scope.exceptions.one': '{n} wyjątek', 'scope.exceptions.few': '{n} wyjątki', 'scope.exceptions.many': '{n} wyjątków',
+    'scope.counts': '{patterns} · {exceptions}. Dopasowanie ścieżki jest sygnałem do sprawdzenia, a nie gotowym werdyktem naruszenia.',
+    'scope.builtIn': '<b>To wbudowana zasada domyślna.</b> Nie dostarczono własnego pliku zasad. Raport nie odtwarza ustawień ochrony z momentu zdarzenia.',
+    'scope.privacy': 'Prywatność', 'scope.privacyText': 'Analiza jest lokalna i działa po fakcie. Pełne prompty, polecenia i wyniki nie trafiają do raportu; ścieżki, opisy zleceń i skrócone identyfikatory są widoczne. Wartości sekretów są ukrywane przed zapisaniem pliku.',
+    'side.local': 'Na twojej maszynie', 'side.localSub': 'Nic nie jest wysyłane. Nic nie jest mierzone.',
+    'index.notices.notify.chat,terminal': 'I w terminalu',
+    'index.notices.notify.chat,os': 'I jako powiadomienie',
+    'table.expand': 'Otwórz tę tabelę na pełną szerokość', 'table.dialog': 'Tabela na pełną szerokość', 'table.close': 'Zamknij tabelę',
+    'scope.paths': 'Jak pokazujemy ścieżki',
+    'scope.pathsFull': 'Ścieżki są pokazane tak, jak zostały zapisane — względem korzenia projektu tam, gdzie w nim leżą.',
+    'scope.pathsShared': '<b>To jest raport do udostępnienia.</b> Nie ma w nim niczego nad korzeniem projektu. To zmniejsza ekspozycję, ale nie anonimizuje — ścieżka wewnątrz repozytorium nadal nazywa to, co nazywa repozytorium.',
+    'scope.root.known': 'Korzeń projektu został odczytany z sesji, więc ścieżki pod nim są pokazane względem niego.',
+    'scope.root.absent': 'Żaden zapis nie niósł korzenia projektu, więc ścieżki są pokazane dokładnie tak, jak je zapisano.',
+    'scope.root.absentShared': 'Żaden zapis nie niósł korzenia projektu, więc niczego nie da się umieścić wewnątrz projektu: każda ścieżka mówiąca, gdzie się zaczyna, jest pokazana jako kategoria.',
+    'scope.root.ambiguousShared': 'Sesja zapisała {n} katalogów roboczych, więc żaden pojedynczy korzeń jej nie opisuje, a każda ścieżka mówiąca, gdzie się zaczyna, jest pokazana jako kategoria.',
+    'scope.root.ambiguous': 'Sesja zapisała {n} katalogów roboczych, więc żaden pojedynczy korzeń projektu jej nie opisuje.',
+    'scope.technical': 'Szczegóły techniczne',
+    'scope.ruleset': 'Reguły redakcji', 'scope.redactions': 'Ukryte wystąpienia wartości', 'scope.distinct': 'Różne ukryte wartości',
+    'scope.protected': 'Chronione treści', 'scope.missingClasses': 'Brakujące klasy skanera', 'scope.none': 'brak',
+    'gaps.chipGaps': 'Zapis ma luki', 'gaps.chipClean': 'Bez wykrytych luk', 'gaps.title': 'Czego nie da się ustalić?',
+    'gaps.sub': 'zapis: {state}',
+    'gaps.tldr': 'Nie ustalamy intencji agenta, pełnego kontekstu jego instrukcji ani potwierdzonego ujawnienia sekretu.',
+    'gaps.record': 'Braki w zapisie', 'gaps.noneFound': 'Nie wykryto braków w strukturze dostarczonego zapisu.',
+    'gaps.unresolved': 'Agenci bez ustalonego zlecenia ({n})', 'gaps.unresolvedNote': 'nie wiemy, kto go uruchomił',
+    'gaps.missing': 'Zlecenia bez ustalonego agenta ({n})',
+    'gaps.howToRead': 'Jak czytać liczby',
+    'gaps.howToReadText': 'Ścieżka wymieniona w poleceniu powłoki liczy się jako dotknięta — część takich trafień to wzmianki, a nie otwarcia pliku.',
+    'gaps.unknownActions': 'Działania bez pewnego wyniku ({n})',
+    'what.main': '<b>Główny agent</b> to asystent, z którym rozmawiasz. Część pracy wykonuje sam, resztę zleca agentom pomocniczym.',
+    'what.agent': "<b>Agent pomocniczy</b> to asystent, któremu inny agent zlecił zadanie. Jego odpowiedź może trafić do rozmowy tamtego agenta.",
+    'what.unresolved': '<b>Nieustalone powiązanie</b>: nie wiemy, kto uruchomił tego agenta. Na grafie jest dołączony do głównego agenta przerywaną linią — to adnotacja, nie ustalony fakt.',
+    "what.file": "<b>Wrażliwy plik</b> pasuje do reguł tej analizy, np. <code>.env</code>. Nie znaczy to, że dostęp był zablokowany ani że plik na pewno zawiera hasła.",
+    "limit": "Raport pokazuje to, co jest w zapisie sesji. Nie mówi, jakie były zamiary agenta ani czy dane trafiły gdzieś poza tę sesję.",
+    "next.hit": "Nic pilnego. Agenci widzieli tylko nazwę pliku.",
+    "next.secret": "Sprawdź, czy to prawdziwe hasło lub klucz. Jeśli tak, zmień je.",
+    "next.named": "Otwórz agenta poniżej, aby zobaczyć, co zrobiło polecenie.",
+    "next.unknown": "Otwórz agenta poniżej, aby zobaczyć, czego brakuje.",
+    "next.block": "Nic nie trzeba robić. Blokada zadziałała.",
+    "next.clean": "Nic nie trzeba robić.",
+    'outcome.succeeded': 'Wykonano', 'outcome.blocked': 'Zablokowano', 'outcome.unknown': 'Brak pewnego wyniku',
+    'table.caption': 'Działania agenta w kolejności zapisanej w jego transkrypcie',
+    'table.step': 'Krok', 'table.tool': 'Narzędzie', 'table.path': 'Chroniona ścieżka', 'table.outcome': 'Wynik', 'table.evidence': 'Dowód',
+    'table.notDetected': 'nie wykryto', 'table.signal': 'Sygnał',
+    'table.empty': 'Brak zapisanych działań. To nie potwierdza, że agent nic nie zrobił.',
+    'skip': 'Przejdź do raportu',
+    'title': 'agentwhy — co wydarzyło się w sesji {id}',
+    "flow.delegated.value": "Uruchomił: {agent}. Jego odpowiedź zawierała ten sam tekst, co {files}.",
+    "flow.delegated.crossed": "Uruchomił: {agent}. Ten sam tekst, co {files}, wrócił od niego; jego odpowiedzi nie ma w tym zapisie.",
+    "flow.returned.crossed": "Ten sam tekst, co {files}, dotarł do: {agent}. Jego odpowiedzi nie ma w tym zapisie.",
+    "flow.delegated.path": "Uruchomił: {agent}. Jego odpowiedź wspomniała {files}, bez zawartości.",
+    "flow.delegated.report": "Uruchomił: {agent}. W jego odpowiedzi nie znaleziono tekstu z wrażliwych plików.",
+    "flow.delegated.unknown": "Uruchomił: {agent}. Nie da się odczytać jego odpowiedzi.",
+    "flow.delegated.awaited": "Uruchomił w tle: {agent}. Jego odpowiedzi nie ma w zapisie.",
+    "flow.returned.value": "Odbiorca: {agent}. Odpowiedź zawierała ten sam tekst, co {files}.",
+    "flow.returned.path": "Odbiorca: {agent}. Odpowiedź wspomniała {files}, bez zawartości.",
+    "flow.returned.report": "Odbiorca: {agent}. W odpowiedzi nie znaleziono tekstu z wrażliwych plików.",
+    "flow.returned.unknown": "Nie da się odczytać jego odpowiedzi.",
+    "flow.returned.awaited": "Działał w tle. Jego odpowiedzi nie ma w zapisie.",
+    "flow.open": "Pokaż krok po kroku ({n})",
+    'steps.how': 'Jak do tego doszło',
+    'steps.count.one': '{n} krok', 'steps.count.few': '{n} kroki', 'steps.count.many': '{n} kroków',
+    'steps.expand': 'Rozwiń',
+    'steps.all': 'Pokaż wszystkie kroki ({n})',
+    'steps.dialog': 'Krok po kroku',
+    'evidence.title': 'Na czym opiera się ta odpowiedź',
+    'evidence.lead': 'Pogrupowane według działania, z zapisami, na których każde się opiera.',
+    "agent.evidence": "Szczegóły: zadanie, pliki, dowody",
+    "wrote.open": "Co napisał tuż przed tym",
+    "flow.kind.reached.value": "Zobaczył zawartość pliku",
+    "flow.kind.reached.path": "Zobaczył nazwę pliku",
+    "flow.kind.reached.named": "Wspomniał plik w poleceniu",
+    "wrote.blank.other": "Wcześniejsze wypowiedzi zapisano bez ich treści ({n}).",
+    "wrote.covers.other": "Ta wypowiedź poprzedzała kilka działań ({n}), nie tylko to jedno.",
+    "flow.records.other": "Gdzie w zapisie",
+    "flow.reached.value": "{did} pokazał mu ten sam tekst, co w {files}.",
+    "return.report.other": "W jego odpowiedzi ({length} znaków) nie znaleziono tekstu z wrażliwych plików.",
+    // plain-report: the answer first, in words a first-time reader needs no glossary for.
+    "verdict.seen.one": "Agent widział <em>zawartość wrażliwego pliku.</em>",
+    "verdict.seen.few": "{n} agenci widzieli <em>zawartość wrażliwych plików.</em>",
+    "verdict.seen.many": "{n} agentów widziało <em>zawartość wrażliwych plików.</em>",
+    "lead.seen.who": "Kto: {agents}.",
+    "lead.seen.files": "Pliki: {files}.",
+    "lead.seen.passed": "Przekazane innemu agentowi przez: {agents}.",
+    "lead.seen.saved": "Zapisane w plikach przez: {agents}.",
+    "lead.seen.next": "Jeśli te pliki zawierają prawdziwe hasła lub klucze, zmień je.",
+    'stat.keys.one': 'możliwy klucz', 'stat.keys.few': 'możliwe klucze', 'stat.keys.many': 'możliwych kluczy',
+    'stat.files.one': 'pasujący plik', 'stat.files.few': 'pasujące pliki', 'stat.files.many': 'pasujących plików',
+    'strip.title': 'Kto co zobaczył',
+    "tier.value.filter": "widział zawartość pliku",
+    "tier.value.chip": "Widział zawartość pliku",
+    "tier.value.row": "widział zawartość",
+    "tier.value.term": "<b>Widział zawartość</b>: ten sam tekst, co w tym pliku, trafił do rozmowy agenta.",
+    "legend.value": "widział zawartość",
+    "graph.seen.yes": "widział zawartość pliku",
+    "graph.seen.maybe": "możliwe hasło lub klucz",
+    "graph.seen.path": "widział tylko nazwę pliku",
+    "graph.seen.named": "nazwa pliku w poleceniu",
+    "graph.seen.unknown": "niepełny zapis",
+    "graph.seen.blocked": "zablokowano",
+    "graph.passed": "przekazał dalej",
+    "graph.saved": "zapisał w pliku",
+    "seen.question": "Czy agent widział zawartość wrażliwego pliku?",
+    "seen.word.yes": "Tak",
+    "seen.word.maybe": "Możliwe",
+    "seen.word.path": "Nie",
+    "seen.word.named": "Nie widać",
+    "seen.word.unknown": "Nie wiadomo",
+    "seen.word.blocked": "Nie",
+    "seen.word.no": "Nie",
+    "seen.word.empty": "Nie wiadomo",
+    "seen.says.yes": "Do jego rozmowy trafił ten sam tekst, co w {files}.",
+    "seen.says.yes.bare": "Do jego rozmowy trafił tekst z wrażliwego pliku.",
+    "seen.says.maybe": "Zobaczył tekst, który wygląda jak hasło lub klucz. Może to też być przykład.",
+    "seen.says.path": "Widział tylko nazwę {files}, nie zawartość.",
+    "seen.says.path.bare": "Widział tylko nazwę wrażliwego pliku, nie zawartość.",
+    "seen.says.named": "Polecenie wspomniało {files}, ale zawartość pliku nie wróciła do agenta.",
+    "seen.says.named.bare": "Polecenie wspomniało wrażliwy plik, ale jego zawartość nie wróciła do agenta.",
+    "seen.says.unknown": "Brakuje części zapisu, więc nie da się tego stwierdzić.",
+    "seen.says.blocked": "Próbował sięgnąć po {files}, ale to zablokowano.",
+    "seen.says.blocked.bare": "Próbował sięgnąć po wrażliwy plik, ale to zablokowano.",
+    "seen.says.no": "Nic nie wskazuje, że dotykał wrażliwych plików.",
+    "seen.says.empty": "Działania tego agenta nie zostały zapisane.",
+    "seen.row.passed": "Przekazał go innemu agentowi",
+    "seen.row.saved": "Zapisał go w pliku",
+    "seen.row.chat": "Napisał go w swoich wiadomościach",
+    "seen.row.command": "Użył go w poleceniu",
+    "yn.yes": "Tak",
+    "yn.no": "Nie",
+    "yn.unknown": "Nie wiadomo",
+    "seen.next.yes": "Jeśli ten plik zawiera prawdziwe hasła lub klucze, zmień je.",
+    "seen.next.maybe": "Sprawdź, czy to prawdziwe hasło lub klucz. Jeśli tak, zmień je.",
+    "seen.next.path": "Nic pilnego. Agent wie tylko, że taki plik istnieje.",
+    "seen.next.named": "W szczegółach poniżej zobaczysz, co zrobiło polecenie.",
+    "seen.next.unknown": "W szczegółach poniżej zobaczysz, czego brakuje.",
+    "seen.next.blocked": "Nic nie trzeba robić. Blokada zadziałała.",
+    "seen.next.no": "Nic nie trzeba robić.",
+    "seen.next.empty": "Sprawdź, czy agentwhy ma dostęp do zapisu tego agenta.",
+    "seen.chip.yes": "Widział zawartość pliku",
+    "seen.chip.maybe": "Możliwe hasło lub klucz",
+    "seen.chip.path": "Widział tylko nazwę pliku",
+    "seen.chip.named": "Nazwa pliku w poleceniu",
+    "seen.chip.unknown": "Niepełny zapis",
+    "seen.chip.blocked": "Zablokowano",
+    "seen.chip.no": "Nic nie znaleziono",
+    "seen.chip.empty": "Brak zapisu",
+    "seen.incomplete": "Brakuje części zapisu, więc ta odpowiedź może być niepełna.",
+    "seen.help": "Skąd to wiadomo?",
+    "seen.helpText": "Wrażliwy plik to plik pasujący do reguł tej analizy, np. <code>.env</code>. Nie znaczy to, że dostęp do niego był zablokowany. agentwhy porównuje tekst: jeśli ten sam tekst jest w takim pliku i w rozmowie agenta, to agent ten tekst widział. Sam tekst nigdy nie jest pokazywany w raporcie.",
+    "target.notSeen": "Agenci widzieli lub używali tylko jego nazwy. Zawartość nie wróciła.",
+    "target.unknown": "Brakuje części zapisu, więc nie wiadomo, czy któryś agent widział zawartość.",
+    "target.blocked": "Każdą próbę dostępu do niego zablokowano.",
+    "next.value": "Jeśli ten plik zawiera prawdziwe hasła lub klucze, zmień je.",
+    "story.value": "Agent widział zawartość tego pliku.",
+    "lead.notBack": "Ich zawartość nie wróciła do agentów.",
+    "target.seen.one": "Zawartość tego pliku widział {n} agent.",
+    "target.seen.few": "Zawartość tego pliku widzieli {n} agenci.",
+    "target.seen.many": "Zawartość tego pliku widziało {n} agentów.",
+    "target.seen.other": "Zawartość tego pliku widzieli {n} agenci.",
+    "lead.seen.more": "i {n} więcej",
+    "index.incomplete": "zapis niepełny",
+};
+const DE = {
+    'quote.open': '\u201E', 'quote.close': '\u201C',
+    'lang.aria': 'Sprache des Berichts',
+    'bar.analysis': 'Sitzungsanalyse',
+    'bar.session': 'Sitzung <code>{id}</code>',
+    'bar.agents.one': '{n} Agent', 'bar.agents.other': '{n} Agenten',
+    'bar.actions.one': '{n} Aktion', 'bar.actions.other': '{n} Aktionen',
+    'bar.record': 'Aufzeichnung: {state}',
+    'bar.policy': "Analyseregel: {level}", 'bar.policyDefault': ' (Standard)',
+    'bar.unknowns': 'Was wir nicht wissen',
+    'rail.nav': 'Abschnitte dieser Seite',
+    'tab.summary': 'Zusammenfassung', 'tab.steps': 'Schritt für Schritt', 'tab.evidence': 'Belege',
+    'tab.group': 'Was dieser Agent getan hat',
+    'side.nav': 'Zurück zur Sitzungsliste',
+    'side.record': 'Aufzeichnung',
+    'rail.sessions': 'Sitzungen',
+    'record.complete': 'vollständig', 'record.partial': 'teilweise', 'record.unresolved': 'ein Teil der Daten ließ sich nicht zuordnen',
+    'files.one': '{n} geschützte Datei', 'files.other': '{n} geschützte Dateien',
+    "verdict.result": "<em>Die Agenten sahen Namen sensibler Dateien.</em>",
+    'verdict.them.one': 'sie', 'verdict.them.other': 'sie',
+    'verdict.appeared.one': 'erschien', 'verdict.appeared.other': 'erschienen',
+    "verdict.mixed": "<em>Die Agenten sahen oder nutzten Namen sensibler Dateien.</em>",
+    "verdict.named": "<em>Agenten griffen nach sensiblen Dateien.</em>",
+    'verdict.were.one': 'wurde', 'verdict.were.other': 'wurden',
+    "verdict.blocked": "Kein Agent kam an eine sensible Datei — <em>{n} {attempts} blockiert</em>.",
+    'verdict.attempts.one': 'Versuch wurde', 'verdict.attempts.other': 'Versuche wurden',
+    "verdict.signals": "<em>Ein Ergebnis enthält etwas, das wie ein Passwort oder Schlüssel aussieht.</em>",
+    "verdict.incomplete": "<em>Das lässt sich nicht sagen</em> — ein Teil der Aufzeichnung fehlt.",
+    "verdict.clear": "Nichts deutet darauf hin, dass Agenten sensible Dateien gesehen haben.",
+    "lead.incompleteCount.one": "Ein Teil der Aufzeichnung fehlt. Aktionen ohne Ergebnis: {n}.",
+    "lead.incompleteCount.other": "Ein Teil der Aufzeichnung fehlt. Aktionen ohne Ergebnis: {n}.",
+    "lead.incomplete": "Ein Teil der Aufzeichnung fehlt.",
+    'lead.noDelegations': 'Für die Hilfsagenten fehlt der Auftrag — ihre Aktionen sind da, ihr Auftrag nicht.',
+    'lead.noGuarantee': 'Das ist keine Garantie, dass nichts offengelegt wurde.',
+    "lead.hint": "Klicke auf einen Agenten für Details.",
+    "verdict.show": "Zeigen:",
+    'filter.title': 'Klicken, um ein- oder auszublenden',
+    "tier.hit.filter": "sah nur Dateinamen", "tier.hit.chip": "Dateiname im Ergebnis", "tier.hit.row": "sah nur den Namen",
+    "tier.hit.term": "<b>Sah nur den Namen</b>: Ein Ergebnis zeigte den Dateinamen. Der Inhalt kam nicht zurück.",
+    "tier.secret.filter": "mögliches Passwort oder Schlüssel", "tier.secret.chip": "Mögliches Passwort oder Schlüssel", "tier.secret.row": "mögliches Passwort oder Schlüssel",
+    "tier.secret.term": "<b>Mögliches Passwort oder Schlüssel</b>: Text, der so aussieht. Es kann ein Beispiel sein. Der Text wird hier nie gezeigt.",
+    "tier.named.filter": "Dateiname im Befehl", "tier.named.chip": "Dateiname im Befehl", "tier.named.row": "im Befehl genannt",
+    "tier.named.term": "<b>Im Befehl genannt</b>: Ein Befehl nannte die Datei, aber ihr Inhalt kam nicht zurück.",
+    "tier.unknown.filter": "unvollständig", "tier.unknown.chip": "Aufzeichnung unvollständig", "tier.unknown.row": "unvollständig",
+    "tier.unknown.term": "<b>Unvollständig</b>: Für eine Aktion fehlt das Ergebnis, daher ist unklar, was passiert ist.",
+    "tier.block.filter": "blockiert", "tier.block.chip": "Blockiert", "tier.block.row": "blockiert",
+    "tier.block.term": "<b>Blockiert</b>: Der Versuch wurde abgelehnt und lieferte nichts.",
+    "tier.clean.filter": "nichts gefunden", "tier.clean.chip": "Nichts gefunden", "tier.clean.row": "nichts gefunden",
+    "tier.clean.term": "<b>Nichts gefunden</b>: Nichts in der Aufzeichnung dieses Agenten betraf sensible Dateien. Fehlende Ergebnisse können trotzdem etwas verbergen.",
+    "strip.hint": "Klicke auf einen Agenten oder eine Datei.",
+    'work.title': 'Wer was gesehen hat',
+    'work.lead': 'Wähle einen Agenten oder eine Datei, um zu sehen, was passiert ist.',
+    'work.mapNote': 'Übereinstimmender Text kann auf mehrere Dateien zeigen. Er beweist nicht, welche Datei geöffnet wurde.',
+    'work.tableAgent': 'Agent',
+    'work.shown': '{shown} von {total} Agenten angezeigt',
+    'foot.local': 'Auf deinem Rechner verarbeitet. Nichts wurde gesendet.',
+    'foot.after': 'Eine Analyse einer vergangenen Sitzung. Sie hat nichts blockiert.',
+    'view.aria': 'Ansicht', 'view.graph': 'Graph', 'view.list': 'Liste',
+    'col.you': 'Du', 'col.main': 'Hauptagent', 'col.mainShort': 'Haupt',
+    'col.agents': 'Hilfsagenten', 'col.agentsShort': 'Helfer',
+    "col.targets": "Sensible Dateien", 'col.targetsShort': 'Dateien',
+    'graph.aria': 'Sitzungsgraph: wer was beauftragt hat, wer was tat und was dabei berührt wurde',
+    'graph.you': 'Du — hier beginnt die Sitzung',
+    "graph.clean": "nichts gefunden", 'graph.cleanSub': 'eingeklappt — klicken, um sie zu sehen', "graph.cleanAria": "Agenten ohne Funde",
+    'graph.gap': 'Auftrag ohne Agent', 'graph.gapSub': 'keine Beschreibung aufgezeichnet',
+    'graph.targetAgents.one': '{n} Agent', 'graph.targetAgents.other': '{n} Agenten',
+    "legend.delegated": "hat beauftragt", "legend.hit": "nur Name", "legend.secret": "mögliches Passwort",
+    "legend.named": "im Befehl genannt", "legend.unknown": "unvollständig", "legend.block": "blockiert", "legend.unresolved": "Auftraggeber unbekannt",
+    'list.aria': 'Agenten der Sitzung, die schwerwiegendsten zuerst',
+    'list.more': '<u><span data-count></span> Agenten ohne Treffer</u> anzeigen',
+    'list.mainTask': 'Führt die Sitzung und verteilt Aufgaben', 'list.unknownTask': 'Auftrag nicht ermittelt', 'list.noDescription': 'Keine Beschreibung aufgezeichnet',
+    'list.gapOut': 'Ausführender nicht ermittelt',
+    'panel.back': 'Zurück zu:&nbsp;',
+    'panel.agentSub.main': 'führt die Sitzung und verteilt Aufgaben', 'panel.agentSub.helper': "Hilfsagent",
+    'step.asked': 'Was beauftragt wurde', 'step.did': 'Was er tat', "step.result": "Was dabei herauskam",
+    "panel.next": "Was tun", 'panel.what': 'Was ist das?', 'panel.evidence': "Auftrag aufgezeichnet unter: {evidence}",
+    "asked.note": "Der Auftrag, wie er in der Sitzung steht.",
+    'asked.main': 'Der Hauptagent arbeitet aus deinem Gespräch heraus. Dieser Bericht zitiert es nicht.',
+    'asked.noDescription': 'Der Auftrag steht in der Aufzeichnung, aber ohne Beschreibung.',
+    'asked.unresolved': 'Wir kennen den Auftrag dieses Agenten nicht — der Aufruf, der ihn gestartet hat, fehlt in der Aufzeichnung.',
+    'did.none': 'Keine Aktionen aufgezeichnet. Das bestätigt nicht, dass der Agent nichts getan hat.',
+    'did.noStories.one': '{n} Aktion aufgezeichnet. Keine davon betraf einen geschützten Pfad.',
+    'did.noStories.other': '{n} Aktionen aufgezeichnet. Keine davon betraf einen geschützten Pfad.',
+    'did.used': 'Nutzte <b>{did}</b>. {note}',
+    'wrote.head.reasoning': "Notiz des Agenten vor dieser Aktion",
+    'wrote.head.said': "Nachricht des Agenten vor dieser Aktion",
+    'wrote.covers.one': "Diese Worte standen vor {n} Aktion.",
+    'wrote.covers.other': "Diese Worte standen vor {n} Aktionen, nicht nur vor dieser.",
+    'wrote.none': "Für diese Aktion wurde keine vorherige Nachricht aufgezeichnet.",
+    'wrote.blank.one': "Die vorherige Nachricht wurde ohne ihren Text aufgezeichnet.",
+    'wrote.blank.other': "Die vorherigen Nachrichten wurden ohne ihren Text aufgezeichnet ({n}).",
+    'wrote.carried': "Der vorherige Text enthielt Daten, die auch in {files} vorkommen. Wir blenden diesen Text aus.",
+    'wrote.cut': 'Nach den ersten {n} Zeichen abgeschnitten.',
+    'wrote.size': 'Er schrieb vor diesem Aufruf {n} Zeichen; diese Ansicht zeigt sie nicht.',
+    "result.link": "Diese Datei ansehen →",
+    "result.signals": "Ein Ergebnis enthält etwas, das wie ein Passwort oder Schlüssel aussieht. Der Text ist verborgen.",
+    "result.signalsLink": "Alle möglichen Passwörter und Schlüssel →",
+    'result.clean': 'Kein Kontakt mit geschützten Dateien gefunden. Das bestätigt nicht die Sicherheit der ganzen Sitzung.',
+    "return.value": "Seine Antwort an den auftraggebenden Agenten enthielt denselben Text wie {files}.",
+    "return.crossed": "Derselbe Text wie {files} erreichte den auftraggebenden Agenten. Seine Antwort ist nicht in dieser Aufzeichnung, ihr Wortlaut lässt sich also nicht zeigen.",
+    "return.path": "Seine Antwort nannte {files}, ohne Inhalt.",
+    "return.report.one": "In seiner Antwort ({length} Zeichen) wurde kein Text aus sensiblen Dateien gefunden.",
+    "return.report.other": "In seiner Antwort ({length} Zeichen) wurde kein Text aus sensiblen Dateien gefunden.",
+    "return.unknown": "Seine Antwort fehlt oder ist unlesbar.",
+    "return.awaited": "Er lief im Hintergrund. Seine Antwort fehlt in der Aufzeichnung.",
+    "return.written": "In seinen eigenen Nachrichten schrieb er denselben Text wie {files}.",
+    "use.file": "Derselbe Text wie in {files} wurde in {targets} geschrieben.",
+    "use.fileProtected": "Derselbe Text wie in {files} wurde in die sensible Datei {targets} geschrieben.",
+    "use.command": "Ein Befehl{programs} enthielt denselben Text wie {files}.",
+    "use.commit": "Ein Commit{programs} enthielt denselben Text wie {files}.",
+    "use.delegation": "Ein Auftrag für einen anderen Agenten enthielt denselben Text wie {files}.",
+    "use.said": "Eine Nachricht enthielt denselben Text wie {files}.",
+    "use.reasoning": "Die Notizen des Agenten enthielten denselben Text wie {files}.",
+    "use.call": "Ein Werkzeugaufruf enthielt denselben Text wie {files}.",
+    "use.source.none": "Frühere Schritte zeigen nicht, woher der Agent ihn hatte.",
+    "use.file.same": "Der Text wurde in {targets} geschrieben.",
+    "use.fileProtected.same": "Der Text wurde in die sensible Datei {targets} geschrieben.",
+    "use.command.same": "Ein Befehl{programs} enthielt den Text.",
+    "use.commit.same": "Ein Commit{programs} enthielt den Text.",
+    "use.delegation.same": "Ein Auftrag für einen anderen Agenten enthielt den Text.",
+    "use.said.same": "Eine Nachricht enthielt den Text.",
+    "use.reasoning.same": "Die Notizen des Agenten enthielten den Text.",
+    "use.call.same": "Ein Werkzeugaufruf enthielt den Text.",
+    'flow.dialog': 'Was geschah, Schritt für Schritt',
+    'flow.close': 'Schließen',
+    "flow.kind.asked": "Bekam einen Auftrag",
+    'flow.kind.reached.succeeded': 'Erreichte eine geschützte Datei', "flow.kind.reached.blocked": "Wurde blockiert", "flow.kind.reached.unknown": "Ergebnis unbekannt",
+    "flow.kind.carried": "Sah denselben Text in einer anderen Datei",
+    "flow.kind.used.file": "Schrieb den Text in eine Datei", "flow.kind.used.command": "Nutzte den Text in einem Befehl", "flow.kind.used.delegation": "Gab den Text an einen anderen Agenten",
+    "flow.kind.used.said": "Schrieb den Text in eine Nachricht", "flow.kind.used.reasoning": "Schrieb den Text in seine Notizen", "flow.kind.used.call": "Gab den Text an ein Werkzeug",
+    "flow.kind.delegated": "Startete einen anderen Agenten", "flow.kind.returned": "Antwortete",
+    "flow.kind.received": "Bekam den Dateiinhalt",
+    "flow.asked": "{by} bat: {asked}",
+    'flow.askedBare': '{by} startete ihn, und keine Beschreibung wurde aufgezeichnet.',
+    "flow.reached.result": "{did} zeigte den Namen {files}, nicht den Inhalt.",
+    "flow.reached.input": "Führte {did} mit {files} aus. Der Inhalt kam nicht zurück.",
+    "flow.reached.printed": "Führte {did} mit {files} aus. Wir sehen, was der Befehl ausgab, aber nicht, wie viel davon bei der KI ankam.",
+    "flow.received": "Code, den er schrieb, gab ihm denselben Text wie in {files}. Der Text kam aus diesem Code, nicht aus einer seiner Aktionen.",
+    "flow.reached.blocked": "Versuchte {did} auf {files}, das wurde blockiert.",
+    "flow.reached.unknown": "Führte {did} auf {files} aus, aber das Ergebnis fehlt.",
+    "flow.carried": "{did} zeigte denselben Text in {named}, die nicht als sensibel markiert ist.",
+    "flow.carriedBare": "{did} zeigte denselben Text. Aus welcher Datei, ist unklar.",
+    "flow.after": "(Der Agent hatte diesen Text in Schritt {n} gesehen.)",
+    "flow.openOther": "Schritte öffnen: {name}",
+    'flow.someAgent': 'ein Agent, den dieser Bericht nicht enthält',
+    "flow.records.one": "Wo in der Aufzeichnung", "flow.records.other": "Wo in der Aufzeichnung",
+    'tldr.valueWrittenOn': ' Er schrieb einen Wert aus einer geschützten Datei in nicht geschützte Dateien.',
+    'files.or': ' oder ',
+    'tldr.valueReturned': ' Seine Antwort enthielt einen Wert aus einer geschützten Datei und erreichte den Agenten, der ihn gestartet hat.',
+    'tldr.valueWritten': ' Er schrieb einen Wert aus einer geschützten Datei in seine eigenen Nachrichten, die das Transkript der Sitzung aufbewahrt.',
+    'tldr.hit': '{name} nutzte <b>{did}</b>. Der Pfad {path} erschien im Ergebnis, obwohl der Aufruf ihn nicht genannt hat.',
+    'tldr.named': '{name} nannte {path} in einem <b>{did}</b>-Aufruf. Der Aufruf lief; die Aufzeichnung zeigt nicht, ob der Inhalt der Datei im Ergebnis stand.',
+    'tldr.unknown': '{name} nutzte <b>{did}</b> bei {path}, aber die Aufzeichnung enthält kein gesichertes Ergebnis.',
+    'tldr.block': '{name} versuchte, {path} zu erreichen (<b>{did}</b>). Die Aufzeichnung bestätigt die Verweigerung.',
+    'tldr.more.one': ' Insgesamt {n} Ereignis an geschützten Pfaden.', 'tldr.more.other': ' Insgesamt {n} Ereignisse an geschützten Pfaden.',
+    'tldr.alsoSignals.one': ' {n} Ergebnis enthält außerdem einen Hinweis auf ein mögliches Geheimnis.',
+    'tldr.alsoSignals.other': ' {n} Ergebnisse enthalten außerdem Hinweise auf mögliche Geheimnisse.',
+    'tldr.onlySignals.one': '{name}: {n} Werkzeugergebnis enthält einen Hinweis auf ein mögliches Geheimnis. Die Werte sind verborgen.',
+    'tldr.onlySignals.other': '{name}: {n} Werkzeugergebnisse enthalten Hinweise auf mögliche Geheimnisse. Die Werte sind verborgen.',
+    'tldr.actions.one': '{name} führte {n} Aktion aus. Keine davon betraf eine geschützte Datei.',
+    'tldr.actions.other': '{name} führte {n} Aktionen aus. Keine davon betraf eine geschützte Datei.',
+    'tldr.noActions': 'Die Aufzeichnung enthält keine einzige Aktion dieses Agenten.',
+    'tldr.unknownActions.one': ' {n} Aktion hat kein gesichertes Ergebnis.', 'tldr.unknownActions.other': ' {n} Aktionen haben kein gesichertes Ergebnis.',
+    "story.blocked": "Dieser Versuch wurde blockiert.", "story.unknown": "Ein Versuch ist sichtbar, sein Ergebnis nicht.",
+    "story.result": "Ein Ergebnis zeigte den Namen einer sensiblen Datei.", "story.input": "Ein Befehl nannte eine sensible Datei und lief.",
+    "source.result": "Der Befehl fragte nicht nach dieser Datei; ihr Name tauchte im Ergebnis auf.",
+    "source.input": "Die Datei wurde im Befehl genannt.",
+    'story.occurrences.one': '{n} Vorkommen', 'story.occurrences.other': '{n} Vorkommen',
+    'story.evidence': 'Beleg: <code>{evidence}</code>', 'story.link': 'Link zum Ereignis #{n}',
+    "agent.stories": "Dateiereignisse ({n})",
+    "agent.shapes": "Mögliche Passwörter oder Schlüssel ({n})", 'agent.actions': 'Alle Aktionen ({n})',
+    'missing.chip': 'Keine Zuordnung', 'missing.title': 'Auftrag ohne ermittelten Agenten', 'missing.sub': 'Auftrag {id}',
+    'missing.tldr': 'Der Auftrag ist sichtbar, aber wir wissen nicht, welcher Agent ihn ausgeführt hat. Wir schreiben ihm keine fremden Aktionen zu.',
+    'missing.description': 'Aufgezeichnete Beschreibung', 'missing.none': 'Keine Beschreibung aufgezeichnet.',
+    "target.why": "Warum sie als sensibel gilt",
+    "target.whyPatterns.one": "Sie passt auf die Regel {patterns}.",
+    "target.whyPatterns.other": "Sie passt auf die Regeln {patterns}.",
+    "target.whyPolicy": "Sie passt auf die Regeln dieser Analyse.",
+    "target.whyNote": "Das heißt nicht, dass sie wirklich Passwörter enthält.",
+    "target.who": "Wer sie berührt hat ({n})",
+    "signal.title": "Mögliche Passwörter oder Schlüssel", "signal.name": "Mögliche Passwörter oder Schlüssel",
+    'signal.sub.one': '{n} Ergebnis · Werte verborgen', 'signal.sub.other': '{n} Ergebnisse · Werte verborgen',
+    "signal.tldr.one": "Ergebnisse, die wie ein Passwort oder Schlüssel aussehen: {n}. Der Text ist verborgen.",
+    "signal.tldr.other": "Ergebnisse, die wie ein Passwort oder Schlüssel aussehen: {n}. Der Text ist verborgen.",
+    'signal.kinds': 'Arten von Hinweisen', 'signal.who': 'Wer es gesehen hat', 'signal.all': 'Alle Hinweise und Belege ({n})',
+    'signal.results.one': '{n} Ergebnis', 'signal.results.other': '{n} Ergebnisse',
+    'ty.chip': 'Beginn der Sitzung', 'ty.title': 'Du',
+    'ty.tldr': 'Die Sitzung begann mit deinem Gespräch mit dem Hauptagenten. Die Aufzeichnung enthält {agents}, {delegations} und {actions}.',
+    'ty.delegations.one': '{n} Auftrag', 'ty.delegations.other': '{n} Aufträge',
+    'ty.next': 'Was danach geschah',
+    'clean.title.one': '{n} Agent ohne Treffer', 'clean.title.other': '{n} Agenten ohne Treffer',
+    'clean.sub': 'zusammen {actions}',
+    'clean.tldr': 'Diese Agenten berührten keinen geschützten Pfad und sahen kein mögliches Geheimnis. Im Graphen sind sie zu einem Element eingeklappt, bis der Filter „nichts erreicht“ an ist.',
+    'clean.empty': 'Diese Sitzung hat keine Hilfsagenten ohne Treffer.', 'clean.who': 'Wer das ist',
+    'scope.chip': 'Regel und Umfang', 'scope.title': 'Nach welcher Regel entstand dieser Bericht?',
+    'scope.sub': 'Sitzung <code>{id}</code> · Aufzeichnung: {state}',
+    'scope.noRead': 'geschützte Ressourcen dürfen weder gelesen noch durchsucht werden.',
+    'scope.noDisclose': 'Lesen ist erlaubt; Werte dürfen nicht offengelegt werden.',
+    'scope.other': 'siehe die Quelle der Regel unten.',
+    'scope.origin': 'Woher die Regel stammt',
+    'scope.patterns.one': '{n} Schutzmuster', 'scope.patterns.other': '{n} Schutzmuster',
+    'scope.exceptions.one': '{n} Ausnahme', 'scope.exceptions.other': '{n} Ausnahmen',
+    'scope.counts': '{patterns} · {exceptions}. Ein passender Pfad ist ein Hinweis zum Prüfen, kein fertiges Urteil über einen Verstoß.',
+    'scope.builtIn': '<b>Das ist die eingebaute Standardregel.</b> Es wurde keine eigene Regeldatei übergeben. Der Bericht rekonstruiert nicht den Schutz, der zum Zeitpunkt des Ereignisses aktiv war.',
+    'scope.privacy': 'Privatsphäre', 'scope.privacyText': 'Die Analyse ist lokal und läuft im Nachhinein. Vollständige Prompts, Befehle und Ergebnisse gelangen nicht in den Bericht; Pfade, Aufgabenbeschreibungen und gekürzte Kennungen sind sichtbar. Geheime Werte werden vor dem Schreiben der Datei verborgen.',
+    'side.local': 'Auf deinem Rechner', 'side.localSub': 'Nichts wird hochgeladen. Nichts wird gemessen.',
+    'index.notices.notify.chat,terminal': 'Und im Terminal',
+    'index.notices.notify.chat,os': 'Und als Mitteilung',
+    'table.expand': 'Diese Tabelle in voller Breite öffnen', 'table.dialog': 'Tabelle in voller Breite', 'table.close': 'Tabelle schließen',
+    'scope.paths': 'Wie Pfade dargestellt werden',
+    'scope.pathsFull': 'Pfade werden so gezeigt, wie sie geschrieben wurden — relativ zum Projektstamm, sofern sie darunter liegen.',
+    'scope.pathsShared': '<b>Dies ist ein Bericht zum Weitergeben.</b> Nichts oberhalb des Projektstamms erscheint darin. Das verringert die Offenlegung, anonymisiert aber nicht — ein Pfad innerhalb des Repositorys benennt weiterhin das, was das Repository benennt.',
+    'scope.root.known': 'Der Projektstamm wurde aus der Sitzung gelesen, daher werden Pfade darunter relativ dazu gezeigt.',
+    'scope.root.absent': 'Keine Aufzeichnung trug einen Projektstamm, daher werden Pfade genau so gezeigt, wie sie geschrieben wurden.',
+    'scope.root.absentShared': 'Keine Aufzeichnung trug einen Projektstamm, daher lässt sich nichts im Projekt verorten: jeder Pfad, der seinen Anfang nennt, wird als Kategorie gezeigt.',
+    'scope.root.ambiguousShared': 'Die Sitzung hat {n} Arbeitsverzeichnisse aufgezeichnet, daher beschreibt sie kein einzelner Projektstamm und jeder Pfad, der seinen Anfang nennt, wird als Kategorie gezeigt.',
+    'scope.root.ambiguous': 'Die Sitzung hat {n} Arbeitsverzeichnisse aufgezeichnet, daher beschreibt sie kein einzelner Projektstamm.',
+    'scope.technical': 'Technische Details',
+    'scope.ruleset': 'Redaktionsregeln', 'scope.redactions': 'Verborgene Vorkommen von Werten', 'scope.distinct': 'Verschiedene verborgene Werte',
+    'scope.protected': 'Geschützte Inhalte', 'scope.missingClasses': 'Nicht umgesetzte Scannerklassen', 'scope.none': 'keine',
+    'gaps.chipGaps': 'Die Aufzeichnung hat Lücken', 'gaps.chipClean': 'Keine Lücken gefunden', 'gaps.title': 'Was lässt sich nicht ermitteln?',
+    'gaps.sub': 'Aufzeichnung: {state}',
+    'gaps.tldr': 'Wir ermitteln weder die Absicht des Agenten noch den vollen Kontext seiner Anweisungen noch eine bestätigte Offenlegung eines Geheimnisses.',
+    'gaps.record': 'Lücken in der Aufzeichnung', 'gaps.noneFound': 'In der Struktur der gelieferten Aufzeichnung wurden keine Lücken gefunden.',
+    'gaps.unresolved': 'Agenten ohne ermittelten Auftrag ({n})', 'gaps.unresolvedNote': 'wir wissen nicht, wer ihn gestartet hat',
+    'gaps.missing': 'Aufträge ohne ermittelten Agenten ({n})',
+    'gaps.howToRead': 'Wie die Zahlen zu lesen sind',
+    'gaps.howToReadText': 'Ein in einem Shell-Befehl genannter Pfad zählt als berührt — ein Teil davon sind Erwähnungen und kein Öffnen der Datei.',
+    'gaps.unknownActions': 'Aktionen ohne gesichertes Ergebnis ({n})',
+    'what.main': '<b>Der Hauptagent</b> ist der Assistent, mit dem du sprichst. Einen Teil der Arbeit macht er selbst, den Rest gibt er an Hilfsagenten ab.',
+    'what.agent': "<b>Ein Hilfsagent</b> ist ein Assistent, den ein anderer Agent mit einer Aufgabe betraut. Seine Antwort kann Teil des Gesprächs des anderen Agenten werden.",
+    'what.unresolved': '<b>Keine ermittelte Zuordnung</b>: Wir wissen nicht, wer diesen Agenten gestartet hat. Im Graphen hängt er mit gestrichelter Linie am Hauptagenten — das ist eine Anmerkung, keine ermittelte Tatsache.',
+    "what.file": "<b>Eine sensible Datei</b> passt auf die Regeln dieser Analyse, etwa <code>.env</code>. Das heißt weder, dass der Zugriff blockiert war, noch, dass sie wirklich Passwörter enthält.",
+    "limit": "Dieser Bericht zeigt, was die Aufzeichnung der Sitzung enthält. Er sagt nicht, was der Agent beabsichtigte oder ob Daten außerhalb dieser Sitzung weitergegeben wurden.",
+    "next.hit": "Nichts Dringendes. Die Agenten sahen nur den Dateinamen.",
+    "next.secret": "Prüfe, ob es ein echtes Passwort oder ein echter Schlüssel ist. Wenn ja, ändere es.",
+    "next.named": "Öffne unten einen Agenten, um zu sehen, was der Befehl getan hat.",
+    "next.unknown": "Öffne unten einen Agenten, um zu sehen, was fehlt.",
+    "next.block": "Nichts zu tun. Die Sperre hat gegriffen.",
+    "next.clean": "Nichts zu tun.",
+    'outcome.succeeded': 'Ausgeführt', 'outcome.blocked': 'Abgelehnt', 'outcome.unknown': 'Kein gesichertes Ergebnis',
+    'table.caption': 'Die Aktionen des Agenten in der Reihenfolge seiner Aufzeichnung',
+    'table.step': 'Schritt', 'table.tool': 'Werkzeug', 'table.path': 'Geschützter Pfad', 'table.outcome': 'Ergebnis', 'table.evidence': 'Beleg',
+    'table.notDetected': 'nicht erkannt', 'table.signal': 'Hinweis',
+    'table.empty': 'Keine Aktionen aufgezeichnet. Das bestätigt nicht, dass der Agent nichts getan hat.',
+    'skip': 'Zum Bericht springen',
+    'title': 'agentwhy — was in Sitzung {id} geschah',
+    "flow.delegated.value": "Startete {agent}. Dessen Antwort enthielt denselben Text wie {files}.",
+    "flow.delegated.crossed": "Startete {agent}. Derselbe Text wie {files} kam von dort zurück; dessen Antwort ist nicht in dieser Aufzeichnung.",
+    "flow.returned.crossed": "Derselbe Text wie {files} erreichte {agent}. Dessen Antwort ist nicht in dieser Aufzeichnung.",
+    "flow.delegated.path": "Startete {agent}. Dessen Antwort nannte {files}, ohne Inhalt.",
+    "flow.delegated.report": "Startete {agent}. In dessen Antwort wurde kein Text aus sensiblen Dateien gefunden.",
+    "flow.delegated.unknown": "Startete {agent}. Dessen Antwort ließ sich nicht lesen.",
+    "flow.delegated.awaited": "Startete {agent} im Hintergrund. Dessen Antwort fehlt in der Aufzeichnung.",
+    "flow.returned.value": "Seine Antwort an {agent} enthielt denselben Text wie {files}.",
+    "flow.returned.path": "Seine Antwort an {agent} nannte {files}, ohne Inhalt.",
+    "flow.returned.report": "In seiner Antwort an {agent} wurde kein Text aus sensiblen Dateien gefunden.",
+    "flow.returned.unknown": "Seine Antwort ließ sich nicht lesen.",
+    "flow.returned.awaited": "Er lief im Hintergrund. Seine Antwort fehlt in der Aufzeichnung.",
+    "flow.open": "Schritt für Schritt zeigen ({n})",
+    'steps.how': 'Wie es dazu kam',
+    'steps.count.one': '{n} Schritt', 'steps.count.other': '{n} Schritte',
+    'steps.expand': 'Aufklappen',
+    'steps.all': 'Alle {n} Schritte zeigen',
+    'steps.dialog': 'Schritt für Schritt',
+    'evidence.title': 'Worauf diese Antwort beruht',
+    'evidence.lead': 'Nach Aktion gruppiert, mit den Aufzeichnungen, auf denen jede beruht.',
+    "agent.evidence": "Details: Auftrag, Dateien, Belege",
+    "wrote.open": "Was er kurz davor schrieb",
+    "flow.kind.reached.value": "Sah den Dateiinhalt",
+    "flow.kind.reached.path": "Sah einen Dateinamen",
+    "flow.kind.reached.named": "Nannte eine Datei in einem Befehl",
+    "wrote.blank.few": "Die vorherigen Nachrichten wurden ohne ihren Text aufgezeichnet ({n}).",
+    "wrote.blank.many": "Die vorherigen Nachrichten wurden ohne ihren Text aufgezeichnet ({n}).",
+    "wrote.covers.few": "Diese Worte standen vor {n} Aktionen, nicht nur vor dieser.",
+    "wrote.covers.many": "Diese Worte standen vor {n} Aktionen, nicht nur vor dieser.",
+    "flow.reached.value": "{did} zeigte ihm denselben Text wie in {files}.",
+    "return.report.few": "In seiner Antwort ({length} Zeichen) wurde kein Text aus sensiblen Dateien gefunden.",
+    "return.report.many": "In seiner Antwort ({length} Zeichen) wurde kein Text aus sensiblen Dateien gefunden.",
+    // plain-report: the answer first, in words a first-time reader needs no glossary for.
+    "verdict.seen.one": "Ein Agent hat <em>den Inhalt einer sensiblen Datei gesehen.</em>",
+    "verdict.seen.other": "{n} Agenten haben <em>den Inhalt sensibler Dateien gesehen.</em>",
+    "lead.seen.who": "Wer: {agents}.",
+    "lead.seen.files": "Dateien: {files}.",
+    "lead.seen.passed": "An einen anderen Agenten weitergegeben von: {agents}.",
+    "lead.seen.saved": "In Dateien geschrieben von: {agents}.",
+    "lead.seen.next": "Wenn diese Dateien echte Passwörter oder Schlüssel enthalten, ändere sie.",
+    'stat.keys.one': 'möglicher Schlüssel', 'stat.keys.other': 'mögliche Schlüssel',
+    'stat.files.one': 'übereinstimmende Datei', 'stat.files.other': 'übereinstimmende Dateien',
+    'strip.title': 'Wer was gesehen hat',
+    "tier.value.filter": "sah Dateiinhalt",
+    "tier.value.chip": "Dateiinhalt gesehen",
+    "tier.value.row": "sah den Inhalt",
+    "tier.value.term": "<b>Sah den Inhalt</b>: Derselbe Text wie in dieser Datei ist im Gespräch des Agenten gelandet.",
+    "legend.value": "sah Inhalt",
+    "graph.seen.yes": "sah Dateiinhalt",
+    "graph.seen.maybe": "mögliches Passwort",
+    "graph.seen.path": "sah nur Dateinamen",
+    "graph.seen.named": "Dateiname im Befehl",
+    "graph.seen.unknown": "unvollständig",
+    "graph.seen.blocked": "blockiert",
+    "graph.passed": "weitergegeben",
+    "graph.saved": "in Datei geschrieben",
+    "seen.question": "Hat dieser Agent den Inhalt einer sensiblen Datei gesehen?",
+    "seen.word.yes": "Ja",
+    "seen.word.maybe": "Möglich",
+    "seen.word.path": "Nein",
+    "seen.word.named": "Nicht erkennbar",
+    "seen.word.unknown": "Unbekannt",
+    "seen.word.blocked": "Nein",
+    "seen.word.no": "Nein",
+    "seen.word.empty": "Unbekannt",
+    "seen.says.yes": "Derselbe Text wie in {files} ist in seinem Gespräch gelandet.",
+    "seen.says.yes.bare": "Text aus einer sensiblen Datei ist in seinem Gespräch gelandet.",
+    "seen.says.maybe": "Er sah Text, der wie ein Passwort oder Schlüssel aussieht. Es kann auch ein Beispiel sein.",
+    "seen.says.path": "Er sah nur den Namen {files}, nicht den Inhalt.",
+    "seen.says.path.bare": "Er sah nur den Namen einer sensiblen Datei, nicht den Inhalt.",
+    "seen.says.named": "Ein Befehl nannte {files}, aber der Inhalt kam nicht zurück.",
+    "seen.says.named.bare": "Ein Befehl nannte eine sensible Datei, aber der Inhalt kam nicht zurück.",
+    "seen.says.unknown": "Ein Teil der Aufzeichnung fehlt, daher lässt sich das nicht sagen.",
+    "seen.says.blocked": "Er versuchte, auf {files} zuzugreifen, das wurde blockiert.",
+    "seen.says.blocked.bare": "Er versuchte, auf eine sensible Datei zuzugreifen, das wurde blockiert.",
+    "seen.says.no": "Nichts deutet darauf hin, dass er sensible Dateien berührt hat.",
+    "seen.says.empty": "Die Aktionen dieses Agenten wurden nicht aufgezeichnet.",
+    "seen.row.passed": "An einen anderen Agenten weitergegeben",
+    "seen.row.saved": "In eine Datei geschrieben",
+    "seen.row.chat": "In seine Nachrichten geschrieben",
+    "seen.row.command": "In einem Befehl verwendet",
+    "yn.yes": "Ja",
+    "yn.no": "Nein",
+    "yn.unknown": "Unbekannt",
+    "seen.next.yes": "Wenn die Datei echte Passwörter oder Schlüssel enthält, ändere sie.",
+    "seen.next.maybe": "Prüfe, ob es ein echtes Passwort oder ein echter Schlüssel ist. Wenn ja, ändere es.",
+    "seen.next.path": "Nichts Dringendes. Der Agent weiß nur, dass die Datei existiert.",
+    "seen.next.named": "Die Details unten zeigen, was der Befehl getan hat.",
+    "seen.next.unknown": "Die Details unten zeigen, was fehlt.",
+    "seen.next.blocked": "Nichts zu tun. Die Sperre hat gegriffen.",
+    "seen.next.no": "Nichts zu tun.",
+    "seen.next.empty": "Prüfe, ob agentwhy die Aufzeichnung dieses Agenten lesen kann.",
+    "seen.chip.yes": "Dateiinhalt gesehen",
+    "seen.chip.maybe": "Mögliches Passwort oder Schlüssel",
+    "seen.chip.path": "Nur Dateiname gesehen",
+    "seen.chip.named": "Dateiname im Befehl",
+    "seen.chip.unknown": "Aufzeichnung unvollständig",
+    "seen.chip.blocked": "Blockiert",
+    "seen.chip.no": "Nichts gefunden",
+    "seen.chip.empty": "Keine Aufzeichnung",
+    "seen.incomplete": "Ein Teil der Aufzeichnung fehlt, daher kann diese Antwort unvollständig sein.",
+    "seen.help": "Woher weiß agentwhy das?",
+    "seen.helpText": "Eine sensible Datei passt auf die Regeln dieser Analyse, etwa <code>.env</code>. Das heißt nicht, dass der Zugriff blockiert war. agentwhy vergleicht Text: Steht derselbe Text in so einer Datei und im Gespräch eines Agenten, hat der Agent diesen Text gesehen. Der Text selbst wird in diesem Bericht nie gezeigt.",
+    "target.notSeen": "Agenten sahen oder nutzten nur ihren Namen. Der Inhalt kam nicht zurück.",
+    "target.unknown": "Ein Teil der Aufzeichnung fehlt, daher ist unklar, ob ein Agent den Inhalt sah.",
+    "target.blocked": "Jeder Zugriffsversuch wurde blockiert.",
+    "next.value": "Wenn diese Datei echte Passwörter oder Schlüssel enthält, ändere sie.",
+    "story.value": "Der Agent sah den Inhalt dieser Datei.",
+    "lead.notBack": "Deren Inhalt kam nicht zu den Agenten zurück.",
+    "target.seen.one": "1 Agent hat den Inhalt dieser Datei gesehen.",
+    "target.seen.other": "{n} Agenten haben den Inhalt dieser Datei gesehen.",
+    "target.seen.few": "{n} Agenten haben den Inhalt dieser Datei gesehen.",
+    "target.seen.many": "{n} Agenten haben den Inhalt dieser Datei gesehen.",
+    "lead.seen.more": "und {n} weitere",
+    "index.incomplete": "Aufzeichnung unvollständig",
+};
+/**
+ * Exported so a test can ask whether a key is present rather than whether it reads in English: `translator` falls
+ * back to the English table, so a missing translation renders, and only the tables themselves say it is missing.
+ */
+export const TABLES = {
+    en: { ...EN, ...APP_WORDS.en, ...CONVERSATIONS_WORDS.en, ...MONTH_WORDS.en, ...REPORT_WORDS.en, ...SETTINGS_WORDS.en, ...TO_FIX_WORDS.en, ...ONBOARDING_WORDS.en, ...PROJECTS_WORDS.en },
+    pl: { ...PL, ...APP_WORDS.pl, ...CONVERSATIONS_WORDS.pl, ...MONTH_WORDS.pl, ...REPORT_WORDS.pl, ...SETTINGS_WORDS.pl, ...TO_FIX_WORDS.pl, ...ONBOARDING_WORDS.pl, ...PROJECTS_WORDS.pl },
+    de: { ...DE, ...APP_WORDS.de, ...CONVERSATIONS_WORDS.de, ...MONTH_WORDS.de, ...REPORT_WORDS.de, ...SETTINGS_WORDS.de, ...TO_FIX_WORDS.de, ...ONBOARDING_WORDS.de, ...PROJECTS_WORDS.de },
+};