@agentwhy/cli 0.0.0-dev

package/dist/report/render/ui/words/report-words.js

@@ -0,0 +1,2099 @@
+/**
+ * What the report page says (`specs/2026-09-23-the-report-page.md`), in the glossary's words. Values arrive escaped.
+ * The answers of "I'm stuck" are written here in advance (F43): nothing is asked of a model, and none of them asks a
+ * person to paste a key anywhere (guidelines §6).
+ */
+export const REPORT_WORDS = {
+    en: {
+        'rp.title': 'Report · agentwhy',
+        'rp.nav.todo': 'Your to-do list',
+        'rp.nav.helpers': 'How it went',
+        'rp.nav.files': 'Files',
+        'rp.nav.advanced': 'Advanced',
+        'rp.nav.back': '← All conversations',
+        'rp.hero.fact.one': 'Your AI opened a private file.',
+        'rp.hero.fact.other': 'Your AI opened {n} private files.',
+        'rp.hero.todo.one': 'Let’s make it safe.',
+        'rp.hero.todo.other': 'Let’s make them safe.',
+        'rp.hero.done.one': 'You made it safe.',
+        'rp.hero.done.other': 'You made them safe.',
+        'rp.hero.lead': 'Your AI read what it opened, and now it has this information. Follow the steps below, one file at a time.',
+        'rp.guide.start': 'Not sure where to start? I’ll guide you.',
+        'rp.guide.startBody': 'We’ll go one file at a time. About 2 minutes each.',
+        'rp.guide.go': 'Start →',
+        'rp.done.title': 'You’re done. Nice work.',
+        'rp.done.keys': 'The keys the AI saw don’t work anymore.',
+        'rp.done.other': 'You did what could be done for every file.',
+        'rp.todo.heading': 'Your to-do list',
+        'rp.todo.progress': '{done} of {total} done',
+        'rp.col.file': 'File',
+        'rp.col.details': 'Details',
+        'rp.col.action': 'Action',
+        'rp.what': 'What happened',
+        'rp.fix': 'Fix it →',
+        'rp.fixed': 'Done ✓',
+        'rp.nothing.title': 'Your AI didn’t read anything private in this conversation.',
+        'rp.nothing.allowed': 'Your AI read only private files you let it read in this conversation.',
+        'rp.shape.title': 'A result contains something that looks like a password or key.',
+        'rp.shape.fact': 'Something looks like a key.',
+        'rp.shape.action': 'Check if it is real.',
+        'rp.shape.body': 'It was not in a file this project protects. Kind: {kinds}.',
+        'rp.item.keys': 'Keys for {providers}',
+        'rp.item.template': 'A sample file with keys in it',
+        'rp.item.private': 'A private file',
+        'rule.env': 'Passwords and keys',
+        'rule.npmrc': 'App install passwords',
+        'rule.secrets': 'A file in a secret folder',
+        'rule.ssh': 'Computer login keys',
+        'provider.ai': 'Your AI account',
+        'provider.github': 'Your code on GitHub',
+        'provider.gitlab': 'Your code on GitLab',
+        'provider.slack': 'Your Slack app',
+        'provider.cloud': 'Your cloud account',
+        'provider.google': 'Google services your app uses',
+        'provider.payments': 'Payments',
+        'provider.supabase': 'Your Supabase account',
+        'provider.npm': 'Installing and publishing packages',
+        'provider.servers': 'Your servers',
+        'provider.email': 'Sending emails',
+        'provider.database': 'Your database',
+        'provider.backend': 'Your app’s backend',
+        'provider.login': 'Signing people in to your app',
+        'provider.hosting': 'Where your app runs online',
+        'provider.dev': 'Tools you build your app with',
+        'provider.monitoring': 'Error tracking and logs',
+        'provider.analytics': 'Tracking how people use your app',
+        'provider.sms': 'Text messages and calls',
+        'provider.chat': 'Your chat bot',
+        'provider.realtime': 'Live updates and calls in your app',
+        'provider.files': 'Your app’s files, images and videos',
+        'provider.maps': 'Maps in your app',
+        'provider.search': 'Search in your app',
+        'provider.content': 'Your website’s content',
+        'provider.shop': 'Your online shop',
+        'provider.social': 'Connecting to social media',
+        'provider.workspace': 'Your work tools',
+        'wz.keys.guess': 'We think so from its name: {names}',
+        'wz.keys.textGuess': 'Each card is a website your keys are for. Go there, make a new key and delete the old one.',
+        'wz.file': 'File {n} of {total}',
+        'wz.step.keys': 'New keys',
+        'wz.step.app': 'Your app',
+        'wz.step.done': 'Done',
+        'wz.step.limit': 'Limit the damage',
+        'wz.step.stop': 'Stop it next time',
+        'wz.now': 'Now fixing',
+        'wz.context.keys.one': 'Your AI read the keys in {name}. The old keys still work until you change them.',
+        'wz.context.keys.other': '{n} AIs read the keys in {name}. The old keys still work until you change them.',
+        'wz.context.data.one': 'Your AI read {name}. This can’t be taken back, but you can limit the damage.',
+        'wz.context.data.other': '{n} AIs read {name}. This can’t be taken back, but you can limit the damage.',
+        'wz.stepOf': 'Step {n} of 2',
+        'wz.keys.title': 'Let’s make new keys',
+        'wz.keys.text': 'This file has keys for {providers}. Open each one, make a new key and delete the old one.',
+        'wz.keys.textUnnamed': 'Open the file. Each line starts with a name - STRIPE_… means Stripe. Go there and make a new key.',
+        'wz.keys.unnamed': 'The keys in this file',
+        'wz.keys.unnamedWhat': 'Make a new one for each, and delete the old ones.',
+        'wz.keys.others': 'Other keys in this file',
+        'wz.keys.textLines': 'We don’t know where these keys come from. Make a new one where you got each - or, if you made it up yourself, just change it.',
+        'wz.keys.lineWhat': 'Make a new one, and delete the old one.',
+        'wz.keys.notKey': 'Not a key, like NODE_ENV? Just mark it done.',
+        'wz.context.every.one': 'Opening a file shows your AI every line in it - here, {n} key.',
+        'wz.context.every.other': 'Opening a file shows your AI every line in it - here, {n} keys.',
+        'wz.keys.testNote': 'Looks like a test key from its name - less urgent.',
+        'wz.keys.more.one': 'Show 1 more key',
+        'wz.keys.more.other': 'Show {n} more keys',
+        'wz.keys.open.one': '1 key looks public - nothing to change',
+        'wz.keys.open.other': '{n} keys look public - nothing to change',
+        'wz.keys.openWhy': 'From their names, apps show these to every visitor anyway, so changing them doesn’t help. If one of them is a secret, change it too.',
+        'wz.open': 'Open {provider}',
+        'wz.app.title': 'Put the new keys in your app',
+        'wz.app.text': 'Do this yourself — it takes a minute.',
+        'wz.app.warnStrong': 'Don’t paste the new keys into your AI.',
+        'wz.app.warn': 'It would see them again, and we’d be back where we started.',
+        'wz.app.open': 'Open this file on your computer:',
+        'wz.copy': 'Copy location',
+        'wz.copied': 'Copied ✓',
+        'wz.app.lines': 'Find these lines. Replace everything after = with your new key:',
+        'wz.app.placeholder': 'paste new key here',
+        'wz.app.linesGeneric': 'Find the lines with your old keys in them, and replace each key after = with the new one.',
+        'wz.app.save': 'Save the file. If your app is online, change the same keys where it’s hosted too (for example Vercel or Netlify settings).',
+        'wz.data.title': 'Limit the damage',
+        'wz.data.ask': 'What’s in this file?',
+        'wz.data.people': 'People’s details (customers, users, staff)',
+        'wz.data.business': 'A contract or other business document',
+        'wz.data.other': 'Something else private',
+        'wz.data.nothing': 'Nothing private in it',
+        'wz.data.text': 'You can’t take the copy back. But these things help.',
+        'wz.data.report': 'Check whether you must report it',
+        'wz.data.reportWhat': 'In the EU and the UK, a leak of people’s details may have to be reported to the data protection authority within 72 hours of finding it, and the people told if the risk to them is high.',
+        'wz.data.agreement': 'Check what your agreement says',
+        'wz.data.agreementWhat': 'It may say you must tell the other side.',
+        'wz.data.team': 'Tell your security or IT team',
+        'wz.data.teamWhat': 'Let them know which file your AI read. They’ll decide what happens next.',
+        'wz.data.move': 'Move the file out of your project',
+        'wz.data.moveWhat': 'Your AI works in your project folder. Kept outside it, the file is much harder for your AI to reach.',
+        'wz.stop.title': 'Make sure it doesn’t happen again',
+        'wz.stop.text': 'Protect this file. Claude Code will have to ask you before it opens it.',
+        'wz.protect': 'Protect it →',
+        'wz.stop.honest': 'This stops the obvious tries, not every trick. If something slips past, you’ll still see it in your report.',
+        'wz.done.keys.title': 'This file is safe now.',
+        'wz.done.keys.text': 'The keys the AI saw don’t work anymore.',
+        'wz.done.data.title': 'You did what you could.',
+        'wz.done.data.text': 'This file is on your list as done.',
+        'wz.left.one': '1 left to go.',
+        'wz.left.other': '{n} left to go.',
+        'wz.last': 'That was the last one!',
+        'wz.back': '← Back',
+        'wz.skip.keys': 'No real keys here',
+        'wz.skip.data': 'Nothing private in it',
+        'wz.all': 'I did it →',
+        'wz.tickFirst': 'First mark each card as done - just click it.',
+        'wz.pickFirst': 'First pick what’s in the file.',
+        'wz.later': 'Skip for now →',
+        'wz.finish': 'Done ✓',
+        'wz.saving': 'Saving…',
+        'wz.copyCommand': 'Copy',
+        'wz.cmd.mark': 'This page isn\u2019t connected to agentwhy, so it can\u2019t save this. To keep the file on your list as done, run this in your project:',
+        'wz.stop.outside': 'This file is outside your project folder, so this page can\u2019t protect it.',
+        'wz.stop.shared': 'This is a shared copy of the report, so it can\u2019t change anything in the project.',
+        'wz.stop.told': 'You chose Track for this file, so your AI may open it and you’re told when it does. To keep it from Claude Code, set it to Block in Settings.',
+        'wz.nextFile': 'Next file →',
+        'wz.backToList': 'Back to my list',
+        'ask.make': 'How do I make a new {provider} key?',
+        'ask.makeAny': 'How do I make a new key?',
+        'ask.makeA': 'Sign in to {provider}. Keys are usually under Settings, in a section called API keys or Tokens. Make a new one, then delete the old one.',
+        'ask.makeAnyA': 'Look at the key’s line in the file: its name usually says which service it is for. Sign in there; keys are usually under Settings, in a section called API keys or Tokens.',
+        'ask.login': 'What if I don’t have a login?',
+        'ask.loginA': 'Ask whoever set up this service for your app — a teammate, or the developer who built it. Until the key is changed, the old one still works.',
+        'ask.stop': 'Will my app stop working?',
+        'ask.stopA': 'Only for a moment. Your app uses the old key until you put the new one in (step 2). Do both steps close together and it keeps working.',
+        'ask.tell': 'Do I have to tell anyone?',
+        'ask.tellA': 'It depends on what is in the file and where you are. If it holds people’s details, the step above says what the law may ask of you. If you’re unsure, ask your security or IT team.',
+        'ask.who': 'Who can see this now?',
+        'ask.whoA': 'Your AI read it, so it is now part of your conversation with the AI. What happens to that conversation depends on your AI and your account settings.',
+        'ask.next': 'How do I stop this next time?',
+        'ask.nextA': 'Protect the file (step 2). Claude Code will then have to ask you before it opens it, and you’ll still see any attempt in your report.',
+        'pr.title': 'Protect this file?',
+        'pr.sentence': 'This protects {path}. Claude Code won\u2019t be able to open it. If it needs it for a task, it will stop and ask you first. You can undo this anytime.',
+        'pr.option': 'Also protect every file called {name}, wherever it is in your project.',
+        'pr.confirm': 'Yes, protect it',
+        'pr.done': 'Protected ✓',
+        'pr.cmd': 'This page isn\u2019t connected to agentwhy, so it can\u2019t protect the file itself. Run this in your project:',
+        'mp.title': 'Make this file private?',
+        'mp.sentence': 'This adds {path} to your private files, in your settings. Claude Code won\u2019t be able to open it. If it needs it for a task, it will stop and ask you first. You can undo this anytime.',
+        'mp.option': 'Also make every file called {name} private, wherever it is in your project.',
+        'mp.confirm': 'Yes, make it private',
+        'mp.cmd': 'This page isn\u2019t connected to agentwhy, so it can\u2019t change your settings itself. Run this in your project:',
+        'st.heading': 'What happened to this file',
+        'st.summary.keys.one': 'Your AI read the keys in this file — and now it has them.',
+        'st.summary.keys.other': '{n} AIs read the keys in this file — and now they have them.',
+        'st.summary.keysHelper': 'A helper read the keys in this file — and now it has them.',
+        'st.summary.data.one': 'Your AI read this file — and now it has this information.',
+        'st.summary.data.other': '{n} AIs read this file — and now they have this information.',
+        'st.summary.dataHelper': 'A helper read this file — and now it has this information.',
+        'st.summary.reached': 'Something from this file reached your AI — and now it has this information.',
+        'st.tab.story': 'The story',
+        'st.tab.diagram': 'Diagram',
+        'st.tab.record': 'Full record',
+        'st.you': 'You',
+        'st.main': 'Your AI',
+        'st.mainLower': 'your AI',
+        'st.helper': 'Helper {ordinal}',
+        'st.company': 'It was exposed',
+        'st.e.read.keys': 'Opened the file and read the keys',
+        'st.e.read.data': 'Opened the file and read it',
+        'st.e.received.keys': 'Read the keys in what its program handed back',
+        'st.e.received.data': 'Read it in what its program handed back',
+        'st.e.again': 'Read it again',
+        'st.e.helperRead.keys': 'A helper read the keys',
+        'st.e.helperRead.data': 'A helper read it',
+        'st.e.helperReadToo.keys': 'A helper read the keys too',
+        'st.e.helperReadToo.data': 'A helper read it too',
+        'st.e.named': 'Saw its name',
+        'st.e.unknown': 'Tried to open it',
+        'st.e.stopped': 'Tried to open it. It was stopped.',
+        'st.e.passed': 'Passed what it read back to {to}',
+        'st.e.saved': 'Saved a copy',
+        'st.e.handed': 'Handed it to a helper',
+        'st.e.repeated': 'Repeated it in a message',
+        'st.e.used': 'Used it to run something',
+        'st.e.company': 'The AI now has this information',
+        'st.sub.did': 'With {did}.',
+        'st.sub.received': 'A small program it wrote handed back the same text as in this file.',
+        'st.sub.didTimes.one': 'With {did}.',
+        'st.sub.didTimes.other': '{n} times, with {did}.',
+        'st.sub.asked': 'It was asked to “{task}”.',
+        'st.sub.notAsked': 'The record doesn’t say what it was asked to do.',
+        'st.sub.unknown': 'The record doesn’t say what happened.',
+        'st.sub.passed': 'What it sent back held something from this file.',
+        'st.sub.saved': 'In {files}.',
+        'st.sub.savedAny': 'Another file got something from this one.',
+        'st.sub.handed': 'Its instructions to a helper held something from this file.',
+        'st.sub.repeated': 'Its own words held something from this file.',
+        'st.sub.used': 'In {programs}.',
+        'st.sub.usedAny': 'A command or a tool was given something from this file.',
+        'st.sub.company': 'Everything above is now in your conversation with the AI.',
+        'st.stat.opened': 'Times opened',
+        'st.stat.readers': 'AIs that read it',
+        'st.stat.stopped': 'Stopped in time',
+        'st.stat.record': 'Record',
+        'st.complete': 'Complete',
+        'st.gaps': 'Has gaps',
+        'st.rec.every': 'Every time it was opened',
+        'st.rec.count.one': '{n} event · in order',
+        'st.rec.count.other': '{n} events · in order',
+        'st.col.n': '#',
+        'st.col.who': 'Who',
+        'st.col.what': 'What happened',
+        'st.col.tool': 'Tool',
+        'st.col.result': 'Result',
+        'st.col.evidence': 'Evidence',
+        'st.res.succeeded': 'succeeded',
+        'st.res.blocked': 'stopped',
+        'st.res.unknown': 'not recorded',
+        'st.rec.each': 'What each AI did with it',
+        'st.rec.yes': 'YES = it happened',
+        'st.col.role': 'Role',
+        'st.col.read': 'Read it',
+        'st.col.passed': 'Passed it on',
+        'st.col.saved': 'Saved a copy',
+        'st.col.repeated': 'Repeated it',
+        'st.col.used': 'Used in a command',
+        'st.col.actions': 'Actions',
+        'st.role.main': 'The AI you talked to',
+        'st.role.helper': 'Brought in by {who}',
+        'st.role.helperAny': 'Brought in to help',
+        'st.yes': 'YES',
+        'st.no': 'NO',
+        'st.rec.details': 'File details',
+        'st.fact.path': 'Full path',
+        'st.fact.rule': 'Matched rule',
+        'st.fact.why': 'Why it’s private',
+        'st.fact.session': 'Session',
+        'st.fact.complete': 'Record complete?',
+        'st.why.env': 'Files like this usually hold keys and passwords.',
+        'st.why.npmrc': 'It usually holds the password for installing your app’s packages.',
+        'st.why.secrets': 'It’s in a folder kept for secrets.',
+        'st.why.ssh': 'Anyone who has keys like this can log in to your computers.',
+        'st.why.other': 'A rule for this project marks it private.',
+        'st.complete.yes': 'Yes — nothing is missing',
+        'st.complete.no': 'No — part of the record is missing',
+        'st.d.asked': 'asked for help',
+        'st.d.hint': 'Hover a box to see where its lines lead.',
+        'st.d.file': 'your private file',
+        'st.d.company': 'the AI has this information',
+        'st.d.readKeys': 'read the keys',
+        'st.d.readIt': 'read it',
+        'st.d.passed': 'passed it back',
+        'st.d.saved': 'saved a copy',
+        'st.d.stopped': 'was stopped',
+        'st.d.named': 'saw its name',
+        'st.d.times': '{n}×',
+        'st.d.legendRead': 'read it / sent a copy',
+        'st.d.legendWork': 'handed over work',
+        'st.foot': 'We only see what the AI wrote down, not what it was thinking.',
+        'hp.eyebrow': 'Behind the scenes',
+        'hp.fact.one': 'Your AI got help from {n} helper.',
+        'hp.fact.other': 'Your AI got help from {n} helpers.',
+        'hp.some.one': 'Only {n} of them read your private files.',
+        'hp.some.other': 'Only {n} of them read your private files.',
+        'hp.all.one': 'It read your private files.',
+        'hp.all.other': 'All of them read your private files.',
+        'hp.noneRead': 'None of them read your private files.',
+        'hp.lead': 'Helpers are extra AIs your AI brings in to work faster. Here’s who saw your private files.',
+        'hp.tab.list': 'List',
+        'hp.tab.diagram': 'Diagram',
+        'hp.line.read.one': 'Read {n} private file',
+        'hp.line.read.other': 'Read {n} private files',
+        'hp.line.sample': 'Only saw a sample file.',
+        'hp.line.named': 'Only saw a file’s name.',
+        'hp.line.unknown': 'Tried to open a private file. The record doesn’t say what happened.',
+        'hp.line.stopped': 'Tried to open a private file. It was stopped.',
+        'hp.line.none': 'Didn’t touch anything private.',
+        'hp.seeWhat': 'See what →',
+        'hp.safe.one': '<strong>{n} other helper</strong> <span class="fold-rest">didn’t see anything real.</span>',
+        'hp.safe.other': '<strong>{n} other helpers</strong> <span class="fold-rest">didn’t see anything real.</span>',
+        'hp.col.start': 'Start',
+        'hp.col.main': 'Your AI',
+        'hp.col.helpers': 'Helpers',
+        'hp.col.files': 'Files',
+        'hp.key.read': 'Read it',
+        'hp.key.named': 'Only saw the name',
+        'hp.key.stopped': 'Stopped',
+        'hp.key.work': 'Gave work to',
+        'hp.you.sub': 'Asked for the work',
+        'hp.file.named': 'Only its name was seen',
+        'hp.file.unknown': 'Not recorded what happened',
+        'hp.file.stopped': 'Stopped in time',
+        'hp.hint': 'Hover a box to see its lines. Click to open the details.',
+        'hp.job': 'Its job',
+        'hp.mainJob': 'The work you asked for in this conversation.',
+        'hp.opened': 'Did it open a private file?',
+        'hp.yes': 'Yes',
+        'hp.no': 'No',
+        'hp.answer.read': 'It read what’s inside these files:',
+        'hp.answer.sample': 'It saw the name of a sample file, but nothing shows it looked inside.',
+        'hp.answer.named': 'It saw the name of a private file, but nothing shows it looked inside.',
+        'hp.answer.unknown': 'It tried to open a private file, and the record doesn’t say what happened.',
+        'hp.answer.stopped': 'It tried to open a private file. It was stopped in time.',
+        'hp.answer.none': 'It stayed away from your private files.',
+        'hp.next': 'What it did next',
+        'hp.next.passed': 'Passed it to another AI',
+        'hp.next.saved': 'Saved a copy',
+        'hp.next.repeated': 'Repeated it in a message',
+        'hp.next.used': 'Used it to run something',
+        'hp.explain': '✦ Explain this in simple words',
+        'hp.ex.brought': '{who} brought it in to help.',
+        'hp.ex.read': 'It read {files}.',
+        'hp.ex.passed': 'Something from them went on to another AI.',
+        'hp.ex.saved': 'It saved something from them into another file.',
+        'hp.ex.repeated': 'It repeated something from them in its own words.',
+        'hp.ex.used': 'It used something from them to run a command.',
+        'hp.ex.company': 'Everything it read is now in your conversation with the AI.',
+        'hp.fix': 'Fix these files →',
+        'fl.eyebrow': 'Everything it opened',
+        'fl.fact.one': 'Your AI opened {n} file.',
+        'fl.fact.other': 'Your AI opened {n} files.',
+        'fl.some.one': 'Only {n} was private.',
+        'fl.some.other': 'Only {n} were private.',
+        'fl.all.one': 'It was private.',
+        'fl.all.other': 'All of them were private.',
+        'fl.noneRead': 'None of them were private.',
+        'fl.lead': 'The rest were everyday work files. Nothing to do there.',
+        'fl.leadAll': 'Each one is below, with what to do about it.',
+        'fl.leadNone': 'They were everyday work files. Nothing to do there.',
+        'fl.search': 'Find a file',
+        'fl.group.all': 'All files',
+        'fl.group.fix': 'To fix',
+        'fl.group.fixed': 'Already fixed',
+        'fl.did.q': 'What the AI did:',
+        'fl.did.any': 'Anything',
+        'fl.did.read': 'Opened and read it',
+        'fl.did.name': 'Only saw the name',
+        'fl.did.stopped': 'Was stopped',
+        'fl.prot.q': 'Private file:',
+        'fl.prot.any': 'Any',
+        'fl.prot.no': 'Not blocked',
+        'fl.prot.yes': 'Blocked',
+        'fl.prot.na': 'Not private',
+        'fl.prot.told': 'Track',
+        'fl.clear': 'Clear filters',
+        'fl.col.file': 'File',
+        'fl.col.ai': 'AI',
+        'fl.col.prot': 'Private file',
+        'fl.col.mode': 'When your AI reaches it',
+        'fl.col.action': 'Action',
+        'fl.acc.read': 'Read it',
+        'fl.acc.name': 'Name only',
+        'fl.acc.unknown': 'Not recorded',
+        'fl.acc.stopped': 'Stopped',
+        'fl.acc.changed': 'Changed it',
+        'fl.tag.private': 'Private',
+        'fl.tag.na': 'Not private',
+        'fl.mode.yes': 'Blocked',
+        'fl.mode.told': 'Track',
+        'fl.mode.no': 'Not blocked',
+        'fl.mode.unknown': 'Can’t tell',
+        'fl.mode.na': 'Not needed',
+        'fl.act.fix': 'Fix it →',
+        'fl.act.fixed': 'Fixed ✓',
+        'fl.act.none': 'Nothing to do',
+        'fl.protect': 'Protect it →',
+        'fl.makePrivate': 'Make it private →',
+        'fl.tier.read': 'Private files your AI read',
+        'fl.tier.name': 'Private files it only saw the name of',
+        'fl.tier.rest': 'Everything else',
+        'fl.shown': '{shown} of {n} files shown.',
+        'fl.commands': 'Files your AI reached only through a command are listed when they are private.',
+        'fl.noMatch': 'No files match.',
+        'fl.kind.aiNotes': 'Notes for the AI',
+        'fl.kind.notes': 'Notes about your app',
+        'fl.kind.settings': 'App settings',
+        'fl.kind.code': 'Part of your app',
+        'fl.kind.file': 'A file',
+        'fl.w.did': 'What the AI did',
+        'fl.w.prot': 'Protected?',
+        'fl.w.next': 'What to do',
+        'fl.w.did.read': 'Your AI opened this file and read what’s inside.',
+        'fl.w.did.name': 'Your AI saw this file’s name, but nothing shows it read what’s inside.',
+        'fl.w.did.unknown': 'Your AI tried to open this file, and the record doesn’t say what happened.',
+        'fl.w.did.stopped': 'Your AI tried to open this file. It was stopped in time.',
+        'fl.w.did.everydayRead': 'Your AI opened this file and read it.',
+        'fl.w.did.changed': 'Your AI changed this file.',
+        'fl.w.did.everydayStopped': 'Your AI tried to work on this file, and every try was refused.',
+        'fl.w.prot.yes': 'Protected. Claude Code can’t open it without asking you first.',
+        'fl.w.prot.no': 'Not protected. Claude Code can open it anytime.',
+        'fl.w.prot.unknown': 'We couldn’t read your project’s settings, so we can’t tell.',
+        'fl.w.prot.na': 'An everyday work file. No rule marks it private, so it doesn’t need protection.',
+        'fl.w.prot.told': 'You chose Track: your AI may open it, and you’re told when it does.',
+        'fl.w.next.safe': 'Nothing to do. This file is safe.',
+        'fl.w.next.maybe': 'Nothing to do. If you’d rather Claude Code never opens it, protect it.',
+        'fl.w.next.none': 'Nothing to do.',
+        'fl.w.next.told': 'Nothing to do. If you’d rather Claude Code never opens it, set it to Block in Settings.',
+        'adv.eyebrow': 'Advanced',
+        'adv.title': 'The full record',
+        'adv.lead': 'For developers. Every private file and every helper, with the tools used and the evidence behind it.',
+        'adv.tab.files': 'Private files',
+        'adv.tab.helpers': 'Helpers',
+        'adv.stat.files': 'Private files read',
+        'adv.stat.ais': 'AIs involved',
+        'adv.stat.events': 'Events recorded',
+        'adv.stat.fixed': 'Fixed',
+        'adv.col.file': 'File',
+        'adv.col.readBy': 'Read by',
+        'adv.col.access': 'Access',
+        'adv.col.tools': 'Tools',
+        'adv.col.events': 'Events',
+        'adv.col.firstLast': 'First → last record',
+        'adv.col.helper': 'Helper',
+        'adv.col.asked': 'What it was asked',
+        'adv.col.touched': 'Files touched',
+        'adv.col.actions': 'Actions',
+        'adv.needs': 'Needs action · {n}',
+        'adv.fixed': 'Fixed · {n}',
+        'adv.noFiles': 'No private file’s contents reached an AI.',
+        'adv.hint': 'Click a row to see every event for that file.',
+        'adv.status.read': 'Read private files',
+        'adv.status.sample': 'Sample file only',
+        'adv.status.named': 'Only saw a name',
+        'adv.status.unknown': 'Not recorded',
+        'adv.status.stopped': 'Stopped',
+        'adv.status.none': 'Nothing private',
+        'rp.gap.banner': 'Part of this conversation’s record is missing, so this list may be short.',
+        'rp.gap.link': 'See what’s missing →',
+        'rp.gap.fact': 'Nothing to fix that we can see.',
+        'rp.gap.action': 'But part of the record is missing.',
+        'rp.gap.stopped': 'Your protection worked.',
+        'rp.gap.body': 'Part of this conversation’s record is missing. No evidence here is not the same as nothing happened.',
+        'adv.tab.record': 'Record',
+        // 2026-09-27-what-codex-wrote.md X23, X19-X22: what a Codex record cannot show, and what it recorded at the time.
+        'rp.gap.codex.action': 'But Codex doesn’t write down every step.',
+        'rp.gap.codex.legacyAction': 'But Codex didn’t write down its commands.',
+        'rp.gap.codex.lead': 'Codex doesn’t write down every step, so this report may not show everything it opened.',
+        'rp.gap.codex.body': 'It writes down most of what it does. Here’s what it did write down.',
+        'rp.gap.codex.legacy': 'Codex saved this conversation in an older way that doesn’t show which commands it ran. Here’s what it did write down.',
+        'rp.gap.codex.banner': 'Codex doesn’t write down every step, so this list may be missing something.',
+        'rec.recorded': 'What {ai} recorded at the time',
+        'rec.recorded.note': 'These are the settings {ai} had during the conversation. They are not your agentwhy rules: this report checks your private files as they are set now.',
+        'rec.perm.turns.one': '{n} turn',
+        'rec.perm.turns.other': '{n} turns',
+        'rec.perm.approval': 'asks before acting: {value}',
+        'rec.perm.approver': 'answered by: {value}',
+        'rec.perm.sandbox': 'sandbox: {value}',
+        'rec.perm.network': 'network: {value}',
+        'rec.perm.scopes': 'may read in {read} and write in {write} places',
+        'rec.perm.writable': 'May write in',
+        'rec.perm.incomplete': 'Part of it wasn’t understood and is left out.',
+        'rec.who.person': 'you',
+        'rec.who.reviewer': 'the reviewer {ai} runs',
+        'rec.who.unrecognised': 'not known',
+        'rec.who.unrecorded': 'not recorded',
+        'rec.net.allowed': 'on',
+        'rec.net.restricted': 'off',
+        'rec.net.unrecognised': 'not known',
+        'rec.net.unrecorded': 'not recorded',
+        'rec.value.none': 'not recorded',
+        'rec.reviews': 'What the reviewer {ai} runs decided',
+        'rec.review.allowed': 'Allowed an action in a turn ({who}). Which action isn’t recorded.',
+        'rec.review.allowedNoTurn': 'Allowed an action, in no turn the record names.',
+        'rec.review.unrecognised': 'Gave an answer we don’t know. It isn’t read as a refusal.',
+        'rec.review.risk': 'risk: {risk}',
+        'rec.review.why.one': 'its reasons: {n} character, not shown',
+        'rec.review.why.other': 'its reasons: {n} characters, not shown',
+        'rec.q.actions': 'which actions ran',
+        'rec.q.access': 'what an action reached',
+        'rec.q.output-delivery': 'what reached your AI',
+        'rec.q.own-words': 'everything your AI wrote',
+        'rec.q.reasoning': 'what your AI worked out before acting',
+        'rec.q.refusals': 'whether an action was stopped',
+        'rec.q.permissions': 'which permissions were in force',
+        'rec.shapes': 'Key shapes in results',
+        'rec.shapes.none': 'No result carried anything shaped like a key.',
+        // The Record tab (report page spec P61), redrawn 2026-09-29: an answer first, then each gap as a row saying what it
+        // changes, in the reader's language - never the model's English lines.
+        'rec.gap.title.gaps': 'Part of this conversation isn’t in the record',
+        'rec.gap.lead.gaps': 'Everything this report shows is in the record. But something is missing from it, so the report may not show everything: nothing on a list doesn’t mean nothing happened.',
+        'rec.gap.title.clean': 'The record of this conversation is complete',
+        'rec.gap.lead.clean': 'We found nothing missing from it, so this report is built on the whole conversation.',
+        'rec.gap.tag.gaps': 'Has gaps',
+        'rec.gap.tag.clean': 'Complete',
+        'rec.gap.missing': 'Missing from the record',
+        'rec.gap.times.one': 'once',
+        'rec.gap.times.other': '{n} times',
+        'rec.gap.which': 'Show which',
+        'rec.gap.k.session-missing.t': 'The conversation couldn’t be read',
+        'rec.gap.k.session-missing.d': 'Nothing in this report can be taken as a finding.',
+        'rec.gap.k.source-missing.t': 'A part of the record is missing',
+        'rec.gap.k.source-missing.d': 'A file of this conversation - a helper’s, for example - was gone or couldn’t be read, so what happened in it isn’t here.',
+        'rec.gap.k.record-damaged.t': 'A damaged line',
+        'rec.gap.k.record-damaged.d': 'A line of the record couldn’t be read. It may have been cut off while it was being written.',
+        'rec.gap.k.result-missing.t': 'An action with no result',
+        'rec.gap.k.result-missing.d': 'Your AI started it, but the record holds no answer, so we don’t know if it worked or what it returned.',
+        'rec.gap.k.spilled-result-missing.t': 'A long result is gone',
+        'rec.gap.k.spilled-result-missing.d': 'It was kept in a separate file that isn’t there anymore.',
+        'rec.gap.k.outcome-unrecognised.t': 'An ending we don’t know',
+        'rec.gap.k.outcome-unrecognised.d': 'The record marks how an action ended in a way this version of agentwhy doesn’t know, so we don’t guess.',
+        'rec.gap.k.relation-unresolved.t': 'Actions we couldn’t match up',
+        'rec.gap.k.relation-unresolved.d': 'We couldn’t tell for sure which result belongs to which action, so we don’t say how they ended.',
+        'rec.gap.k.result-incomplete.t': 'A text that may be cut short',
+        'rec.gap.k.result-incomplete.d': 'We can say what is in it, but not what isn’t: the missing part may have held more.',
+        'rec.gap.k.answer-unread.t': 'A helper’s answer couldn’t be read',
+        'rec.gap.k.answer-unread.d': 'So we don’t know what it passed back to your AI.',
+        'rec.gap.k.answer-awaited.t': 'A helper’s answer never arrived',
+        'rec.gap.k.answer-awaited.d': 'It worked in the background, and its answer never reached your AI.',
+        'rec.gap.unknown.t': 'Actions with no known ending',
+        'rec.gap.unknown.d': 'We don’t know if they worked or were stopped.',
+        'rec.gap.unresolved.t': 'Helpers with no known start',
+        'rec.gap.unresolved.d': 'We don’t know who brought them in or what they were asked.',
+        'rec.gap.lost.t': 'Helpers asked for but not in the record',
+        'rec.gap.lost.d': 'Your AI asked for help, but the helper’s own record isn’t here, so what it did isn’t shown.',
+        'rec.cap.h': 'What this record can’t show',
+        'rec.cap.lead': 'Nothing broke: {ai} doesn’t write these down, or we haven’t checked yet whether it does. So the report can neither confirm them nor rule them out.',
+        'rec.cap.tag.absent': 'Not written down',
+        'rec.cap.tag.unmeasured': 'Not checked yet',
+        'rec.cap.shown': '{ai} does write down {list}.',
+        'rec.cap.t.actions': 'Which actions ran',
+        'rec.cap.d.actions': 'There may have been more than the report shows.',
+        'rec.cap.t.access': 'What an action opened',
+        'rec.cap.d.access': 'A command may have opened a file the report doesn’t name.',
+        'rec.cap.t.output-delivery': 'What reached your AI',
+        'rec.cap.d.output-delivery': 'We can’t tell for sure which results your AI actually saw.',
+        'rec.cap.t.own-words': 'Everything your AI wrote',
+        'rec.cap.d.own-words': 'Some of its messages may not be in the record.',
+        'rec.cap.t.reasoning': 'What your AI thought before acting',
+        'rec.cap.d.reasoning': 'We can’t show why it chose a step.',
+        'rec.cap.t.refusals': 'Whether an action was stopped',
+        'rec.cap.d.refusals': 'When an action was stopped, the record may not say so.',
+        'rec.cap.t.permissions': 'Which permissions your AI had',
+        'rec.cap.d.permissions': 'We can’t show what it was allowed to do.',
+        'rec.note': 'Even from a complete record, a report can’t tell why your AI did something, everything it was told, or whether a key it saw actually leaked. A file name in a command counts as reached - sometimes it is only a mention, not an opening.',
+        'rec.how.h': 'How we checked this conversation',
+        'rec.how.rule': 'What counts as a problem',
+        'rec.how.rule.no-read': 'Your AI opening or searching a private file',
+        'rec.how.rule.no-disclose': 'Your AI passing on something from a private file. Reading it is allowed.',
+        'rec.how.rule.other': 'A rule this page doesn’t describe: see the technical details',
+        'rec.how.files': 'Which files are private',
+        'rec.how.files.builtIn': 'agentwhy’s built-in list: {patterns}, {exceptions}',
+        'rec.how.files.own': 'Your own list: {patterns}, {exceptions}',
+        'rec.how.files.note': 'Checked against the list as it is now, not as it was during the conversation. A name that matches is a reason to look, not proof that something leaked.',
+        'rec.how.paths': 'File paths',
+        'rec.how.paths.full': 'Shown in full',
+        'rec.how.paths.shared': 'Shortened for sharing',
+        'rec.how.root.known': 'Relative to your project’s folder.',
+        'rec.how.root.absent': 'Exactly as written: the record doesn’t say which folder the project is in.',
+        'rec.how.root.ambiguous': 'Exactly as written: the conversation worked in {n} folders, so no one of them is the project’s.',
+        'rec.how.session': 'Conversation ID',
+        'rec.how.level': 'Rule',
+        'rec.how.origin': 'Where the rule came from',
+        'rec.runs.none': 'No AI did anything with a private file, so there is no run to show.',
+        'rec.actions.one': 'Every action it took ({n})',
+        'rec.actions.other': 'Every action it took ({n})',
+        'rec.runs.lead': 'Each AI’s steps with private files, in the order of the record.',
+        'rec.runs.key.coral': 'Had the file’s text',
+        'rec.runs.key.blue': 'Only the name',
+        'rec.runs.key.amber': 'Not known',
+        'rec.runs.key.mint': 'Stopped',
+        'rec.cameBack': 'What came back',
+        'st.unknownYn': 'NOT KNOWN',
+        'st.e.inResult.keys': 'Saw the keys in what a command printed',
+        'st.e.inResult.data': 'Saw what\u2019s inside in what a command printed',
+        'st.sub.inResult': 'No command asked for this file. {did} printed it.',
+        'st.sub.lines.one': 'A search printed 1 line of this file, with {did}.',
+        'st.sub.lines.other': 'A search printed {n} lines of this file, with {did}.',
+        'st.sub.inResultLines.one': 'No command asked for this file. {did} printed 1 line of it.',
+        'st.sub.inResultLines.other': 'No command asked for this file. {did} printed {n} lines of it.',
+        'hp.line.empty': 'Its actions were not recorded.',
+        'hp.answer.empty': 'Its actions were not recorded, so this can\u2019t say what it did. That does not mean it did nothing.',
+        'adv.status.empty': 'Not recorded',
+        'rp.when': 'Report from {when}',
+        'st.col.time': 'Time',
+        'st.rec.timesNote': 'Times are when each line was written. The order is the record\u2019s.',
+        'hp.alone.fact': 'Your AI worked alone.',
+        'hp.alone.unsure': 'Your AI has no helpers in the record.',
+        'hp.alone.lead': 'Helpers are extra AIs your AI can bring in to work faster. This time it brought in none. Here’s what it did itself.',
+        'hp.alone.unsure.lead': 'Part of the record is missing, so we can’t say it worked alone. Here’s what your AI did itself.',
+        'hp.alone.empty.lead': 'That doesn’t mean nothing happened. It means this report can’t say what did.',
+        'hp.alone.read.one': 'It read {n} private file.',
+        'hp.alone.read.other': 'It read {n} private files.',
+        'hp.alone.sample.one': 'It only saw a sample file.',
+        'hp.alone.sample.other': 'It only saw sample files.',
+        'hp.alone.named.one': 'It only saw a private file’s name.',
+        'hp.alone.named.other': 'It only saw the names of {n} private files.',
+        'hp.alone.unknown': 'It tried to open a private file. The record doesn’t say what happened.',
+        'hp.alone.stopped': 'It tried to open a private file. It was stopped in time.',
+        'hp.alone.none': 'It didn’t touch anything private.',
+        'hp.alone.empty': 'Its own actions weren’t recorded either.',
+        'rp.clean.seeFiles': 'See every file it opened',
+        'rp.clean.stopped.one': 'It tried to open {n} private file. It was stopped in time.',
+        'rp.clean.stopped.other': 'It tried to open {n} private files. It was stopped in time.',
+        'rp.clean.stoppedLine': 'Your protection worked. Nothing to do.',
+        'rp.clean.unknown.one': 'It tried to open {n} private file.',
+        'rp.clean.unknown.other': 'It tried to open {n} private files.',
+        'rp.clean.unknownLine': 'The record doesn\u2019t say what happened.',
+        'rp.clean.helpers.one': 'It brought in {n} helper.',
+        'rp.clean.helpers.other': 'It brought in {n} helpers.',
+        'rp.clean.helpersClean.one': 'It didn\u2019t read your private files.',
+        'rp.clean.helpersClean.other': 'None of them read your private files.',
+        'rp.clean.helpersUnknown.one': 'Not everything it did was recorded.',
+        'rp.clean.helpersUnknown.other': 'Not everything they did was recorded.',
+        'rp.clean.seeHelpers': 'See how it went',
+        'rp.clean.record': 'See the full record',
+        'rp.nothing.fact': 'All good.',
+        'rp.nothing.action': 'Nothing to fix.',
+        'rp.nothing.back': 'Done — back to conversations',
+        'rp.asked': 'You asked',
+        'rp.clean.heading': 'What happened',
+        'rp.clean.private': 'It didn’t open any private file.',
+        'rp.clean.privateTag': 'None',
+        'rp.clean.privateLine': 'Your passwords, keys and customer data stayed closed.',
+        'rp.clean.privateShape': 'No file marked private was opened. The warning above is about something in a result.',
+        'rp.clean.allowed.one': 'It read {n} private file you let it read.',
+        'rp.clean.allowed.other': 'It read {n} private files you let it read.',
+        'rp.clean.allowedLine.one': 'You chose Track for it, and what it read held no key we recognise. Nothing to do.',
+        'rp.clean.allowedLine.other': 'You chose Track for them, and what it read held no key we recognise. Nothing to do.',
+        'rp.clean.named.one': 'It saw {n} private file name.',
+        'rp.clean.named.other': 'It saw {n} private file names.',
+        'rp.clean.namedLine.one': 'It didn’t see what is inside, so nothing to do.',
+        'rp.clean.namedLine.other': 'It didn’t see what is inside them, so nothing to do.',
+        'rp.clean.namedLineGap.one': 'The record doesn’t show whether it saw what is inside.',
+        'rp.clean.namedLineGap.other': 'The record doesn’t show whether it saw what is inside them.',
+        'rp.clean.noHelpers': 'It worked alone.',
+        'rp.clean.noHelpersTag': 'No helpers',
+        'rp.clean.alone': 'It didn’t start any other AI to help.',
+        'rp.ask.title': 'Questions about this report? Ask me.',
+        'rp.ask.name': 'What does “saw the name” mean?',
+        'rp.ask.nameA': 'Your AI saw the file’s name, not what is in it.\nA name can show up in a list of files, or in a command that didn’t print the file.\nNothing from inside the file reached your AI, so there is nothing to change.',
+        'rp.ask.safe': 'Is my data safe?',
+        'rp.ask.safeA': 'Nothing here shows your AI read a private file.\nIt didn’t open any file marked private in this conversation.\nWe only see what your AI wrote down, not what it was thinking.',
+        'rp.ask.safeAllowedA': 'Your AI read only the private files you let it read. You chose Track for them.\nWhat it read held no key we recognise, so there is nothing to change.\nIf Claude Code should never open one of them, switch it to Block in Settings.',
+        'rp.ask.change': 'Should I change anything?',
+        'rp.ask.changeA': 'No. Nothing here needs fixing.\nIf there is a file your AI should never open, add it to your private files. From then on, every report shows when your AI reaches it.',
+        'rp.dev.title': 'Details for your developer',
+        'rp.shape.next': 'If it is a real key, change it where it was made: until then, anyone with it can use it.',
+        'rp.shape.link': 'See where it appeared \u2192',
+        'fl.noneListed': 'Your AI didn\u2019t open any file we can list.',
+        'fl.names.one': '<strong>{n} file name it only saw</strong> <span class="fold-rest">Nothing shows it was opened, or that it is in your project.</span>',
+        'fl.names.other': '<strong>{n} file names it only saw</strong> <span class="fold-rest">Nothing shows these were opened, or that they are in your project.</span>',
+        'wz.data.askHelp': 'Open the file and look at what\u2019s in it. Pick what fits best, and we\u2019ll show you what to do.',
+        'wz.data.peopleWhat': 'Names, emails, phone numbers or addresses of real people - customers, users, staff.',
+        'wz.data.businessWhat': 'An agreement, an invoice, prices or plans you would only share with some people.',
+        'wz.data.otherWhat': 'Anything else you wouldn\u2019t post in public - notes, exports, logins that aren\u2019t keys.',
+    },
+    pl: {
+        'rp.title': 'Raport · agentwhy',
+        'rp.nav.todo': 'Twoja lista',
+        'rp.nav.helpers': 'Przebieg',
+        'rp.nav.files': 'Pliki',
+        'rp.nav.advanced': 'Zaawansowane',
+        'rp.nav.back': '← Wszystkie rozmowy',
+        'rp.hero.fact.one': 'Twoje AI otworzyło prywatny plik.',
+        'rp.hero.fact.few': 'Twoje AI otworzyło {n} prywatne pliki.',
+        'rp.hero.fact.many': 'Twoje AI otworzyło {n} prywatnych plików.',
+        'rp.hero.todo.one': 'Zabezpieczmy go.',
+        'rp.hero.todo.few': 'Zabezpieczmy je.',
+        'rp.hero.todo.many': 'Zabezpieczmy je.',
+        'rp.hero.done.one': 'Zabezpieczyłeś go.',
+        'rp.hero.done.few': 'Zabezpieczyłeś je.',
+        'rp.hero.done.many': 'Zabezpieczyłeś je.',
+        'rp.hero.lead': 'Twoje AI przeczytało to, co otworzyło, i teraz ma te informacje. Idź krok po kroku, jeden plik na raz.',
+        'rp.guide.start': 'Nie wiesz, od czego zacząć? Poprowadzę cię.',
+        'rp.guide.startBody': 'Jeden plik na raz. Około 2 minut na każdy.',
+        'rp.guide.go': 'Zaczynamy →',
+        'rp.done.title': 'Gotowe. Dobra robota.',
+        'rp.done.keys': 'Klucze, które widziało AI, już nie działają.',
+        'rp.done.other': 'Zrobiłeś, co się dało, przy każdym pliku.',
+        'rp.todo.heading': 'Twoja lista',
+        'rp.todo.progress': '{done} z {total} zrobione',
+        'rp.col.file': 'Plik',
+        'rp.col.details': 'Szczegóły',
+        'rp.col.action': 'Akcja',
+        'rp.what': 'Co się stało',
+        'rp.fix': 'Napraw →',
+        'rp.fixed': 'Zrobione ✓',
+        'rp.nothing.title': 'Twoje AI nie przeczytało w tej rozmowie nic prywatnego.',
+        'rp.nothing.allowed': 'Twoje AI przeczytało w tej rozmowie tylko prywatne pliki, na które mu pozwoliłeś.',
+        'rp.shape.title': 'W wyniku jest coś, co wygląda na hasło albo klucz.',
+        'rp.shape.fact': 'Coś wygląda na klucz.',
+        'rp.shape.action': 'Sprawdź, czy jest prawdziwy.',
+        'rp.shape.body': 'Nie było w pliku, który chroni ten projekt. Rodzaj: {kinds}.',
+        'rp.item.keys': 'Klucze do {providers}',
+        'rp.item.template': 'Przykładowy plik z kluczami',
+        'rp.item.private': 'Prywatny plik',
+        'rule.env': 'Hasła i klucze',
+        'rule.npmrc': 'Hasła do instalowania aplikacji',
+        'rule.secrets': 'Plik w tajnym folderze',
+        'rule.ssh': 'Klucze logowania do komputerów',
+        'provider.ai': 'Twoje konto AI',
+        'provider.github': 'Twój kod na GitHubie',
+        'provider.gitlab': 'Twój kod na GitLabie',
+        'provider.slack': 'Twoja aplikacja Slack',
+        'provider.cloud': 'Twoje konto w chmurze',
+        'provider.google': 'Usługi Google, z których korzysta aplikacja',
+        'provider.payments': 'Płatności',
+        'provider.supabase': 'Twoje konto Supabase',
+        'provider.npm': 'Instalowanie i publikowanie paczek',
+        'provider.servers': 'Twoje serwery',
+        'provider.email': 'Wysyłanie e-maili',
+        'provider.database': 'Twoja baza danych',
+        'provider.backend': 'Zaplecze twojej aplikacji',
+        'provider.login': 'Logowanie do twojej aplikacji',
+        'provider.hosting': 'Gdzie działa twoja aplikacja',
+        'provider.dev': 'Narzędzia, którymi budujesz aplikację',
+        'provider.monitoring': 'Śledzenie błędów i logi',
+        'provider.analytics': 'Statystyki korzystania z aplikacji',
+        'provider.sms': 'SMS-y i połączenia',
+        'provider.chat': 'Twój bot na czacie',
+        'provider.realtime': 'Powiadomienia na żywo i rozmowy w aplikacji',
+        'provider.files': 'Pliki, zdjęcia i filmy twojej aplikacji',
+        'provider.maps': 'Mapy w twojej aplikacji',
+        'provider.search': 'Wyszukiwarka w twojej aplikacji',
+        'provider.content': 'Treści twojej strony',
+        'provider.shop': 'Twój sklep internetowy',
+        'provider.social': 'Połączenie z mediami społecznościowymi',
+        'provider.workspace': 'Twoje narzędzia do pracy',
+        'wz.keys.guess': 'Tak sądzimy po nazwie: {names}',
+        'wz.keys.textGuess': 'Każda karta to strona, do której są twoje klucze. Wejdź tam, zrób nowy klucz i usuń stary.',
+        'wz.file': 'Plik {n} z {total}',
+        'wz.step.keys': 'Nowe klucze',
+        'wz.step.app': 'Twoja aplikacja',
+        'wz.step.done': 'Gotowe',
+        'wz.step.limit': 'Ogranicz szkody',
+        'wz.step.stop': 'Na przyszłość',
+        'wz.now': 'Teraz naprawiasz',
+        'wz.context.keys.one': 'Twoje AI przeczytało klucze w {name}. Stare klucze działają, dopóki ich nie zmienisz.',
+        'wz.context.keys.few': '{n} AI przeczytały klucze w {name}. Stare klucze działają, dopóki ich nie zmienisz.',
+        'wz.context.keys.many': '{n} AI przeczytało klucze w {name}. Stare klucze działają, dopóki ich nie zmienisz.',
+        'wz.context.data.one': 'Twoje AI przeczytało {name}. Tego nie da się cofnąć, ale możesz ograniczyć szkody.',
+        'wz.context.data.few': '{n} AI przeczytały {name}. Tego nie da się cofnąć, ale możesz ograniczyć szkody.',
+        'wz.context.data.many': '{n} AI przeczytało {name}. Tego nie da się cofnąć, ale możesz ograniczyć szkody.',
+        'wz.stepOf': 'Krok {n} z 2',
+        'wz.keys.title': 'Zróbmy nowe klucze',
+        'wz.keys.text': 'W tym pliku są klucze do {providers}. Otwórz każdy, zrób nowy klucz i usuń stary.',
+        'wz.keys.textUnnamed': 'Otwórz plik. Każda linia zaczyna się od nazwy - STRIPE_… to Stripe. Wejdź tam i zrób nowy klucz.',
+        'wz.keys.unnamed': 'Klucze w tym pliku',
+        'wz.keys.unnamedWhat': 'Zrób nowy dla każdego i usuń stare.',
+        'wz.keys.others': 'Pozostałe klucze w tym pliku',
+        'wz.keys.textLines': 'Nie wiemy, skąd są te klucze. Zrób nowy tam, skąd masz każdy - a jeśli to klucz wymyślony przez ciebie, po prostu go zmień.',
+        'wz.keys.lineWhat': 'Zrób nowy i usuń stary.',
+        'wz.keys.notKey': 'To nie klucz, jak NODE_ENV? Po prostu oznacz jako zrobione.',
+        'wz.context.every.one': 'Otwarcie pliku pokazuje AI każdą linię - tutaj {n} klucz.',
+        'wz.context.every.few': 'Otwarcie pliku pokazuje AI każdą linię - tutaj {n} klucze.',
+        'wz.context.every.many': 'Otwarcie pliku pokazuje AI każdą linię - tutaj {n} kluczy.',
+        'wz.context.every.other': 'Otwarcie pliku pokazuje AI każdą linię - tutaj {n} klucza.',
+        'wz.keys.testNote': 'Po nazwie wygląda na klucz testowy - mniej pilne.',
+        'wz.keys.more.one': 'Pokaż jeszcze 1 klucz',
+        'wz.keys.more.few': 'Pokaż jeszcze {n} klucze',
+        'wz.keys.more.many': 'Pokaż jeszcze {n} kluczy',
+        'wz.keys.more.other': 'Pokaż jeszcze {n} klucza',
+        'wz.keys.open.one': '1 klucz wygląda na publiczny - nic do zmiany',
+        'wz.keys.open.few': '{n} klucze wyglądają na publiczne - nic do zmiany',
+        'wz.keys.open.many': '{n} kluczy wygląda na publiczne - nic do zmiany',
+        'wz.keys.open.other': '{n} klucza wygląda na publiczne - nic do zmiany',
+        'wz.keys.openWhy': 'Po nazwach sądzimy, że aplikacje i tak pokazują je każdemu odwiedzającemu, więc zmiana nic nie da. Jeśli któryś z nich jest sekretem, zmień też jego.',
+        'wz.open': 'Otwórz {provider}',
+        'wz.app.title': 'Wstaw nowe klucze do aplikacji',
+        'wz.app.text': 'Zrób to sam — to zajmie minutę.',
+        'wz.app.warnStrong': 'Nie wklejaj nowych kluczy do swojego AI.',
+        'wz.app.warn': 'Zobaczyłoby je znowu i wrócilibyśmy do punktu wyjścia.',
+        'wz.app.open': 'Otwórz ten plik na swoim komputerze:',
+        'wz.copy': 'Kopiuj ścieżkę',
+        'wz.copied': 'Skopiowano ✓',
+        'wz.app.lines': 'Znajdź te linie. Zastąp wszystko po = nowym kluczem:',
+        'wz.app.placeholder': 'wklej tu nowy klucz',
+        'wz.app.linesGeneric': 'Znajdź linie ze starymi kluczami i zastąp każdy klucz po = nowym.',
+        'wz.app.save': 'Zapisz plik. Jeśli aplikacja działa w internecie, zmień te same klucze także tam, gdzie jest hostowana (np. w ustawieniach Vercel albo Netlify).',
+        'wz.data.title': 'Ogranicz szkody',
+        'wz.data.ask': 'Co jest w tym pliku?',
+        'wz.data.people': 'Dane osób (klientów, użytkowników, pracowników)',
+        'wz.data.business': 'Umowa albo inny dokument firmowy',
+        'wz.data.other': 'Coś innego prywatnego',
+        'wz.data.nothing': 'Nie ma w nim nic prywatnego',
+        'wz.data.text': 'Kopii nie da się odzyskać. Ale te kroki pomagają.',
+        'wz.data.report': 'Sprawdź, czy musisz to zgłosić',
+        'wz.data.reportWhat': 'W UE i Wielkiej Brytanii wyciek danych osób może wymagać zgłoszenia do organu ochrony danych w ciągu 72 godzin od wykrycia, a przy wysokim ryzyku także powiadomienia tych osób.',
+        'wz.data.agreement': 'Sprawdź, co mówi umowa',
+        'wz.data.agreementWhat': 'Może wymagać powiadomienia drugiej strony.',
+        'wz.data.team': 'Powiedz zespołowi bezpieczeństwa albo IT',
+        'wz.data.teamWhat': 'Daj im znać, który plik przeczytało AI. Oni zdecydują, co dalej.',
+        'wz.data.move': 'Przenieś plik poza projekt',
+        'wz.data.moveWhat': 'Twoje AI pracuje w folderze projektu. Poza nim plik jest dla AI dużo trudniej dostępny.',
+        'wz.stop.title': 'Niech to się nie powtórzy',
+        'wz.stop.text': 'Ochroń ten plik. Claude Code będzie musiał zapytać cię, zanim go otworzy.',
+        'wz.protect': 'Chroń →',
+        'wz.stop.honest': 'To zatrzymuje oczywiste próby, nie każdą sztuczkę. Jeśli coś się prześlizgnie, i tak zobaczysz to w raporcie.',
+        'wz.done.keys.title': 'Ten plik jest teraz bezpieczny.',
+        'wz.done.keys.text': 'Klucze, które widziało AI, już nie działają.',
+        'wz.done.data.title': 'Zrobiłeś, co się dało.',
+        'wz.done.data.text': 'Ten plik jest na liście jako zrobiony.',
+        'wz.left.one': 'Został 1.',
+        'wz.left.few': 'Zostały {n}.',
+        'wz.left.many': 'Zostało {n}.',
+        'wz.last': 'To był ostatni!',
+        'wz.back': '← Wstecz',
+        'wz.skip.keys': 'Nie ma tu prawdziwych kluczy',
+        'wz.skip.data': 'Nie ma w nim nic prywatnego',
+        'wz.all': 'Gotowe →',
+        'wz.tickFirst': 'Najpierw oznacz każdą kartę jako zrobioną - wystarczy ją kliknąć.',
+        'wz.pickFirst': 'Najpierw wybierz, co jest w pliku.',
+        'wz.later': 'Pomiń na razie →',
+        'wz.finish': 'Gotowe ✓',
+        'wz.saving': 'Zapisuję…',
+        'wz.copyCommand': 'Kopiuj',
+        'wz.cmd.mark': 'Ta strona nie jest połączona z agentwhy, więc nie może tego zapisać. Żeby plik został na liście jako zrobiony, uruchom to w projekcie:',
+        'wz.stop.outside': 'Ten plik jest poza folderem projektu, więc ta strona nie może go chronić.',
+        'wz.stop.shared': 'To udostępniona kopia raportu, więc nie może niczego zmienić w projekcie.',
+        'wz.stop.told': 'Dla tego pliku wybrałeś Obserwuje, więc twoje AI może go otworzyć, a ty dostajesz o tym wiadomość. Żeby Claude Code go nie otwierał, ustaw Blokuj w Ustawieniach.',
+        'wz.nextFile': 'Następny plik →',
+        'wz.backToList': 'Wróć do listy',
+        'ask.make': 'Jak zrobić nowy klucz {provider}?',
+        'ask.makeAny': 'Jak zrobić nowy klucz?',
+        'ask.makeA': 'Zaloguj się do {provider}. Klucze są zwykle w Ustawieniach, w sekcji API keys albo Tokens. Zrób nowy, potem usuń stary.',
+        'ask.makeAnyA': 'Spójrz na linię klucza w pliku: jego nazwa zwykle mówi, do jakiej usługi jest. Zaloguj się tam; klucze są zwykle w Ustawieniach, w sekcji API keys albo Tokens.',
+        'ask.login': 'Co, jeśli nie mam loginu?',
+        'ask.loginA': 'Zapytaj osobę, która ustawiła tę usługę dla aplikacji — kogoś z zespołu albo programistę. Dopóki klucz nie jest zmieniony, stary działa.',
+        'ask.stop': 'Czy aplikacja przestanie działać?',
+        'ask.stopA': 'Tylko na chwilę. Aplikacja używa starego klucza, dopóki nie wstawisz nowego (krok 2). Zrób oba kroki blisko siebie, a będzie działać.',
+        'ask.tell': 'Czy muszę komuś powiedzieć?',
+        'ask.tellA': 'To zależy od tego, co jest w pliku i gdzie jesteś. Jeśli są w nim dane osób, krok powyżej mówi, czego może wymagać prawo. Jeśli nie wiesz, zapytaj zespół bezpieczeństwa albo IT.',
+        'ask.who': 'Kto może to teraz zobaczyć?',
+        'ask.whoA': 'Twoje AI to przeczytało, więc jest to teraz częścią twojej rozmowy z AI. Co dalej dzieje się z tą rozmową, zależy od twojego AI i ustawień twojego konta.',
+        'ask.next': 'Jak zapobiec temu następnym razem?',
+        'ask.nextA': 'Ochroń plik (krok 2). Wtedy Claude Code będzie musiał zapytać cię, zanim go otworzy, a każdą próbę i tak zobaczysz w raporcie.',
+        'pr.title': 'Chronić ten plik?',
+        'pr.sentence': 'To chroni {path}. Claude Code nie będzie mógł go otworzyć. Jeśli będzie go potrzebował, zatrzyma się i najpierw zapyta. Możesz to w każdej chwili cofnąć.',
+        'pr.option': 'Chroń też każdy plik o nazwie {name}, gdziekolwiek jest w projekcie.',
+        'pr.confirm': 'Tak, chroń',
+        'pr.done': 'Chroniony ✓',
+        'pr.cmd': 'Ta strona nie jest połączona z agentwhy, więc sama nie ochroni pliku. Uruchom to w projekcie:',
+        'mp.title': 'Oznaczyć ten plik jako prywatny?',
+        'mp.sentence': 'To dodaje {path} do twoich plików prywatnych, w ustawieniach. Claude Code nie będzie mógł go otworzyć. Jeśli będzie go potrzebował, zatrzyma się i najpierw zapyta. Możesz to w każdej chwili cofnąć.',
+        'mp.option': 'Oznacz też każdy plik o nazwie {name}, gdziekolwiek jest w projekcie.',
+        'mp.confirm': 'Tak, oznacz jako prywatny',
+        'mp.cmd': 'Ta strona nie jest połączona z agentwhy, więc sama nie zmieni ustawień. Uruchom to w projekcie:',
+        'st.heading': 'Co się stało z tym plikiem',
+        'st.summary.keys.one': 'Twoje AI przeczytało klucze z tego pliku — i teraz je ma.',
+        'st.summary.keys.few': '{n} AI przeczytały klucze z tego pliku — i teraz je mają.',
+        'st.summary.keys.many': '{n} AI przeczytało klucze z tego pliku — i teraz je mają.',
+        'st.summary.keys.other': '{n} AI przeczytało klucze z tego pliku — i teraz je mają.',
+        'st.summary.keysHelper': 'Pomocnik przeczytał klucze z tego pliku — i teraz je ma.',
+        'st.summary.data.one': 'Twoje AI przeczytało ten plik — i teraz ma te informacje.',
+        'st.summary.data.few': '{n} AI przeczytały ten plik — i teraz mają te informacje.',
+        'st.summary.data.many': '{n} AI przeczytało ten plik — i teraz mają te informacje.',
+        'st.summary.data.other': '{n} AI przeczytało ten plik — i teraz mają te informacje.',
+        'st.summary.dataHelper': 'Pomocnik przeczytał ten plik — i teraz ma te informacje.',
+        'st.summary.reached': 'Coś z tego pliku dotarło do twojego AI — i teraz ma te informacje.',
+        'st.tab.story': 'Historia',
+        'st.tab.diagram': 'Diagram',
+        'st.tab.record': 'Pełny zapis',
+        'st.you': 'Ty',
+        'st.main': 'Twoje AI',
+        'st.mainLower': 'twojego AI',
+        'st.helper': 'Pomocnik {ordinal}',
+        'st.company': 'Zostało ujawnione',
+        'st.e.read.keys': 'Otworzyło plik i przeczytało klucze',
+        'st.e.read.data': 'Otworzyło plik i go przeczytało',
+        'st.e.received.keys': 'Przeczytało klucze w tym, co oddał jego program',
+        'st.e.received.data': 'Przeczytało go w tym, co oddał jego program',
+        'st.e.again': 'Przeczytało go ponownie',
+        'st.e.helperRead.keys': 'Pomocnik przeczytał klucze',
+        'st.e.helperRead.data': 'Pomocnik go przeczytał',
+        'st.e.helperReadToo.keys': 'Pomocnik też przeczytał klucze',
+        'st.e.helperReadToo.data': 'Pomocnik też go przeczytał',
+        'st.e.named': 'Zobaczyło jego nazwę',
+        'st.e.unknown': 'Próbowało go otworzyć',
+        'st.e.stopped': 'Próbowało go otworzyć. Zostało zatrzymane.',
+        'st.e.passed': 'Przekazało to, co przeczytało, do {to}',
+        'st.e.saved': 'Zapisało kopię',
+        'st.e.handed': 'Przekazało to pomocnikowi',
+        'st.e.repeated': 'Powtórzyło to w wiadomości',
+        'st.e.used': 'Użyło tego, żeby coś uruchomić',
+        'st.e.company': 'AI ma teraz te informacje',
+        'st.sub.did': 'Przez {did}.',
+        'st.sub.received': 'Mały program, który napisało, oddał mu ten sam tekst, co w tym pliku.',
+        'st.sub.didTimes.one': 'Przez {did}.',
+        'st.sub.didTimes.few': '{n} razy, przez {did}.',
+        'st.sub.didTimes.many': '{n} razy, przez {did}.',
+        'st.sub.didTimes.other': '{n} razy, przez {did}.',
+        'st.sub.asked': 'Poproszono go: „{task}”.',
+        'st.sub.notAsked': 'Zapis nie mówi, o co go poproszono.',
+        'st.sub.unknown': 'Zapis nie mówi, co się stało.',
+        'st.sub.passed': 'To, co odesłało, zawierało coś z tego pliku.',
+        'st.sub.saved': 'W {files}.',
+        'st.sub.savedAny': 'Inny plik dostał coś z tego.',
+        'st.sub.handed': 'Jego polecenie dla pomocnika zawierało coś z tego pliku.',
+        'st.sub.repeated': 'Jego własne słowa zawierały coś z tego pliku.',
+        'st.sub.used': 'W {programs}.',
+        'st.sub.usedAny': 'Polecenie albo narzędzie dostało coś z tego pliku.',
+        'st.sub.company': 'Wszystko powyżej jest teraz w twojej rozmowie z AI.',
+        'st.stat.opened': 'Ile razy otwarty',
+        'st.stat.readers': 'AI, które go przeczytały',
+        'st.stat.stopped': 'Zatrzymane w porę',
+        'st.stat.record': 'Zapis',
+        'st.complete': 'Pełny',
+        'st.gaps': 'Ma luki',
+        'st.rec.every': 'Każde otwarcie',
+        'st.rec.count.one': '{n} zdarzenie · po kolei',
+        'st.rec.count.few': '{n} zdarzenia · po kolei',
+        'st.rec.count.many': '{n} zdarzeń · po kolei',
+        'st.rec.count.other': '{n} zdarzenia · po kolei',
+        'st.col.n': '#',
+        'st.col.who': 'Kto',
+        'st.col.what': 'Co się stało',
+        'st.col.tool': 'Narzędzie',
+        'st.col.result': 'Wynik',
+        'st.col.evidence': 'Dowód',
+        'st.res.succeeded': 'udało się',
+        'st.res.blocked': 'zatrzymane',
+        'st.res.unknown': 'brak zapisu',
+        'st.rec.each': 'Co każde AI z nim zrobiło',
+        'st.rec.yes': 'TAK = to się stało',
+        'st.col.role': 'Rola',
+        'st.col.read': 'Przeczytało',
+        'st.col.passed': 'Przekazało dalej',
+        'st.col.saved': 'Zapisało kopię',
+        'st.col.repeated': 'Powtórzyło',
+        'st.col.used': 'Użyło w poleceniu',
+        'st.col.actions': 'Działania',
+        'st.role.main': 'AI, z którym rozmawiałeś',
+        'st.role.helper': 'Wezwany przez: {who}',
+        'st.role.helperAny': 'Wezwany do pomocy',
+        'st.yes': 'TAK',
+        'st.no': 'NIE',
+        'st.rec.details': 'Szczegóły pliku',
+        'st.fact.path': 'Pełna ścieżka',
+        'st.fact.rule': 'Pasująca reguła',
+        'st.fact.why': 'Dlaczego jest prywatny',
+        'st.fact.session': 'Sesja',
+        'st.fact.complete': 'Pełny zapis?',
+        'st.why.env': 'Takie pliki zwykle zawierają klucze i hasła.',
+        'st.why.npmrc': 'Zwykle zawiera hasło do instalowania pakietów twojej aplikacji.',
+        'st.why.secrets': 'Leży w folderze na sekrety.',
+        'st.why.ssh': 'Takie klucze pozwalają zalogować się do twoich komputerów.',
+        'st.why.other': 'Reguła dla tego projektu oznacza go jako prywatny.',
+        'st.complete.yes': 'Tak — niczego nie brakuje',
+        'st.complete.no': 'Nie — brakuje części zapisu',
+        'st.d.asked': 'poprosiłeś o pomoc',
+        'st.d.hint': 'Najedź na pole, żeby zobaczyć, dokąd prowadzą jego linie.',
+        'st.d.file': 'twój prywatny plik',
+        'st.d.company': 'AI ma te informacje',
+        'st.d.readKeys': 'przeczytało klucze',
+        'st.d.readIt': 'przeczytało go',
+        'st.d.passed': 'przekazało dalej',
+        'st.d.saved': 'zapisało kopię',
+        'st.d.stopped': 'zostało zatrzymane',
+        'st.d.named': 'zobaczyło nazwę',
+        'st.d.times': '{n}×',
+        'st.d.legendRead': 'przeczytało / wysłało kopię',
+        'st.d.legendWork': 'przekazało pracę',
+        'st.foot': 'Widzimy tylko to, co AI zapisało, nie to, co myślało.',
+        'hp.eyebrow': 'Za kulisami',
+        'hp.fact.one': 'Twoje AI skorzystało z pomocy {n} pomocnika.',
+        'hp.fact.few': 'Twoje AI skorzystało z pomocy {n} pomocników.',
+        'hp.fact.many': 'Twoje AI skorzystało z pomocy {n} pomocników.',
+        'hp.fact.other': 'Twoje AI skorzystało z pomocy {n} pomocników.',
+        'hp.some.one': 'Tylko {n} z nich przeczytał twoje prywatne pliki.',
+        'hp.some.few': 'Tylko {n} z nich przeczytało twoje prywatne pliki.',
+        'hp.some.many': 'Tylko {n} z nich przeczytało twoje prywatne pliki.',
+        'hp.some.other': 'Tylko {n} z nich przeczytało twoje prywatne pliki.',
+        'hp.all.one': 'Przeczytał twoje prywatne pliki.',
+        'hp.all.few': 'Wszyscy przeczytali twoje prywatne pliki.',
+        'hp.all.many': 'Wszyscy przeczytali twoje prywatne pliki.',
+        'hp.all.other': 'Wszyscy przeczytali twoje prywatne pliki.',
+        'hp.noneRead': 'Żaden z nich nie przeczytał twoich prywatnych plików.',
+        'hp.lead': 'Pomocnicy to dodatkowe AI, które twoje AI wzywa, żeby pracować szybciej. Oto kto widział twoje prywatne pliki.',
+        'hp.tab.list': 'Lista',
+        'hp.tab.diagram': 'Diagram',
+        'hp.line.read.one': 'Przeczytał {n} prywatny plik',
+        'hp.line.read.few': 'Przeczytał {n} prywatne pliki',
+        'hp.line.read.many': 'Przeczytał {n} prywatnych plików',
+        'hp.line.read.other': 'Przeczytał {n} prywatnego pliku',
+        'hp.line.sample': 'Widział tylko przykładowy plik.',
+        'hp.line.named': 'Widział tylko nazwę pliku.',
+        'hp.line.unknown': 'Próbował otworzyć prywatny plik. Zapis nie mówi, co się stało.',
+        'hp.line.stopped': 'Próbował otworzyć prywatny plik. Został zatrzymany.',
+        'hp.line.none': 'Nie dotknął niczego prywatnego.',
+        'hp.seeWhat': 'Zobacz co →',
+        'hp.safe.one': '<strong>{n} inny pomocnik</strong> <span class="fold-rest">nie widział niczego prawdziwego.</span>',
+        'hp.safe.few': '<strong>{n} inni pomocnicy</strong> <span class="fold-rest">nie widzieli niczego prawdziwego.</span>',
+        'hp.safe.many': '<strong>{n} innych pomocników</strong> <span class="fold-rest">nie widziało niczego prawdziwego.</span>',
+        'hp.safe.other': '<strong>{n} innego pomocnika</strong> <span class="fold-rest">nie widziało niczego prawdziwego.</span>',
+        'hp.col.start': 'Start',
+        'hp.col.main': 'Twoje AI',
+        'hp.col.helpers': 'Pomocnicy',
+        'hp.col.files': 'Pliki',
+        'hp.key.read': 'Przeczytał',
+        'hp.key.named': 'Widział tylko nazwę',
+        'hp.key.stopped': 'Zatrzymany',
+        'hp.key.work': 'Dał pracę',
+        'hp.you.sub': 'Zleciłeś pracę',
+        'hp.file.named': 'Widziano tylko nazwę',
+        'hp.file.unknown': 'Brak zapisu, co się stało',
+        'hp.file.stopped': 'Zatrzymano w porę',
+        'hp.hint': 'Najedź na pole, żeby zobaczyć jego linie. Kliknij, żeby otworzyć szczegóły.',
+        'hp.job': 'Jego zadanie',
+        'hp.mainJob': 'Praca, o którą prosiłeś w tej rozmowie.',
+        'hp.opened': 'Czy otworzył prywatny plik?',
+        'hp.yes': 'Tak',
+        'hp.no': 'Nie',
+        'hp.answer.read': 'Przeczytał zawartość tych plików:',
+        'hp.answer.sample': 'Widział nazwę przykładowego pliku, ale nic nie wskazuje, że zajrzał do środka.',
+        'hp.answer.named': 'Widział nazwę prywatnego pliku, ale nic nie wskazuje, że zajrzał do środka.',
+        'hp.answer.unknown': 'Próbował otworzyć prywatny plik, a zapis nie mówi, co się stało.',
+        'hp.answer.stopped': 'Próbował otworzyć prywatny plik. Został zatrzymany w porę.',
+        'hp.answer.none': 'Trzymał się z dala od twoich prywatnych plików.',
+        'hp.next': 'Co zrobił potem',
+        'hp.next.passed': 'Przekazał to innemu AI',
+        'hp.next.saved': 'Zapisał kopię',
+        'hp.next.repeated': 'Powtórzył to w wiadomości',
+        'hp.next.used': 'Użył tego, żeby coś uruchomić',
+        'hp.explain': '✦ Wyjaśnij to prostymi słowami',
+        'hp.ex.brought': '{who} wezwało go do pomocy.',
+        'hp.ex.read': 'Przeczytał {files}.',
+        'hp.ex.passed': 'Coś z nich trafiło dalej, do innego AI.',
+        'hp.ex.saved': 'Zapisał coś z nich w innym pliku.',
+        'hp.ex.repeated': 'Powtórzył coś z nich własnymi słowami.',
+        'hp.ex.used': 'Użył czegoś z nich, żeby uruchomić polecenie.',
+        'hp.ex.company': 'Wszystko, co przeczytał, jest teraz w twojej rozmowie z AI.',
+        'hp.fix': 'Napraw te pliki →',
+        'fl.eyebrow': 'Wszystko, co otworzyło',
+        'fl.fact.one': 'Twoje AI otworzyło {n} plik.',
+        'fl.fact.few': 'Twoje AI otworzyło {n} pliki.',
+        'fl.fact.many': 'Twoje AI otworzyło {n} plików.',
+        'fl.fact.other': 'Twoje AI otworzyło {n} pliku.',
+        'fl.some.one': 'Tylko {n} był prywatny.',
+        'fl.some.few': 'Tylko {n} były prywatne.',
+        'fl.some.many': 'Tylko {n} było prywatnych.',
+        'fl.some.other': 'Tylko {n} było prywatnych.',
+        'fl.all.one': 'Był prywatny.',
+        'fl.all.few': 'Wszystkie były prywatne.',
+        'fl.all.many': 'Wszystkie były prywatne.',
+        'fl.all.other': 'Wszystkie były prywatne.',
+        'fl.noneRead': 'Żaden nie był prywatny.',
+        'fl.lead': 'Reszta to zwykłe pliki robocze. Nie ma tam nic do zrobienia.',
+        'fl.leadAll': 'Każdy jest poniżej, z tym, co z nim zrobić.',
+        'fl.leadNone': 'To były zwykłe pliki robocze. Nie ma tam nic do zrobienia.',
+        'fl.search': 'Znajdź plik',
+        'fl.group.all': 'Wszystkie pliki',
+        'fl.group.fix': 'Do naprawy',
+        'fl.group.fixed': 'Już naprawione',
+        'fl.did.q': 'Co zrobiło AI:',
+        'fl.did.any': 'Cokolwiek',
+        'fl.did.read': 'Otworzyło i przeczytało',
+        'fl.did.name': 'Widziało tylko nazwę',
+        'fl.did.stopped': 'Zostało zatrzymane',
+        'fl.prot.q': 'Plik prywatny:',
+        'fl.prot.any': 'Dowolnie',
+        'fl.prot.no': 'Niezablokowany',
+        'fl.prot.yes': 'Zablokowany',
+        'fl.prot.na': 'Nie prywatny',
+        'fl.prot.told': 'Obserwuje',
+        'fl.clear': 'Wyczyść filtry',
+        'fl.col.file': 'Plik',
+        'fl.col.ai': 'AI',
+        'fl.col.prot': 'Plik prywatny',
+        'fl.col.mode': 'Gdy Twoje AI po niego sięgnie',
+        'fl.col.action': 'Działanie',
+        'fl.acc.read': 'Przeczytało',
+        'fl.acc.name': 'Tylko nazwa',
+        'fl.acc.unknown': 'Brak zapisu',
+        'fl.acc.stopped': 'Zatrzymane',
+        'fl.acc.changed': 'Zmieniło',
+        'fl.tag.private': 'Prywatny',
+        'fl.tag.na': 'Nie prywatny',
+        'fl.mode.yes': 'Zablokowany',
+        'fl.mode.told': 'Obserwuje',
+        'fl.mode.no': 'Niezablokowany',
+        'fl.mode.unknown': 'Nie wiadomo',
+        'fl.mode.na': 'Niepotrzebne',
+        'fl.act.fix': 'Napraw →',
+        'fl.act.fixed': 'Naprawione ✓',
+        'fl.act.none': 'Nic do zrobienia',
+        'fl.protect': 'Chroń →',
+        'fl.makePrivate': 'Oznacz jako prywatny →',
+        'fl.tier.read': 'Prywatne pliki, które przeczytało twoje AI',
+        'fl.tier.name': 'Prywatne pliki, których widziało tylko nazwę',
+        'fl.tier.rest': 'Cała reszta',
+        'fl.shown': 'Pokazano {shown} z {n} plików.',
+        'fl.commands': 'Pliki, do których AI dotarło tylko przez polecenie, są na liście, gdy są prywatne.',
+        'fl.noMatch': 'Żaden plik nie pasuje.',
+        'fl.kind.aiNotes': 'Notatki dla AI',
+        'fl.kind.notes': 'Notatki o twojej aplikacji',
+        'fl.kind.settings': 'Ustawienia aplikacji',
+        'fl.kind.code': 'Część twojej aplikacji',
+        'fl.kind.file': 'Plik',
+        'fl.w.did': 'Co zrobiło AI',
+        'fl.w.prot': 'Chroniony?',
+        'fl.w.next': 'Co zrobić',
+        'fl.w.did.read': 'Twoje AI otworzyło ten plik i przeczytało jego zawartość.',
+        'fl.w.did.name': 'Twoje AI widziało nazwę tego pliku, ale nic nie wskazuje, że przeczytało zawartość.',
+        'fl.w.did.unknown': 'Twoje AI próbowało otworzyć ten plik, a zapis nie mówi, co się stało.',
+        'fl.w.did.stopped': 'Twoje AI próbowało otworzyć ten plik. Zostało zatrzymane w porę.',
+        'fl.w.did.everydayRead': 'Twoje AI otworzyło ten plik i go przeczytało.',
+        'fl.w.did.changed': 'Twoje AI zmieniło ten plik.',
+        'fl.w.did.everydayStopped': 'Twoje AI próbowało pracować na tym pliku i każda próba została odrzucona.',
+        'fl.w.prot.yes': 'Chroniony. Claude Code nie otworzy go bez pytania cię najpierw.',
+        'fl.w.prot.no': 'Niechroniony. Claude Code może go otworzyć w każdej chwili.',
+        'fl.w.prot.unknown': 'Nie udało się odczytać ustawień projektu, więc nie wiadomo.',
+        'fl.w.prot.na': 'Zwykły plik roboczy. Żadna reguła nie oznacza go jako prywatny, więc nie potrzebuje ochrony.',
+        'fl.w.prot.told': 'Wybrałeś Obserwuje: twoje AI może go otworzyć, a ty dostajesz o tym wiadomość.',
+        'fl.w.next.safe': 'Nic do zrobienia. Ten plik jest bezpieczny.',
+        'fl.w.next.maybe': 'Nic do zrobienia. Jeśli wolisz, żeby Claude Code nigdy go nie otwierał, chroń go.',
+        'fl.w.next.none': 'Nic do zrobienia.',
+        'fl.w.next.told': 'Nic do zrobienia. Jeśli wolisz, żeby Claude Code nigdy go nie otwierał, ustaw Blokuj w Ustawieniach.',
+        'adv.eyebrow': 'Zaawansowane',
+        'adv.title': 'Pełny zapis',
+        'adv.lead': 'Dla programistów. Każdy prywatny plik i każdy pomocnik, z użytymi narzędziami i dowodami.',
+        'adv.tab.files': 'Prywatne pliki',
+        'adv.tab.helpers': 'Pomocnicy',
+        'adv.stat.files': 'Przeczytane prywatne pliki',
+        'adv.stat.ais': 'Zaangażowane AI',
+        'adv.stat.events': 'Zapisane zdarzenia',
+        'adv.stat.fixed': 'Naprawione',
+        'adv.col.file': 'Plik',
+        'adv.col.readBy': 'Czytał',
+        'adv.col.access': 'Dostęp',
+        'adv.col.tools': 'Narzędzia',
+        'adv.col.events': 'Zdarzenia',
+        'adv.col.firstLast': 'Pierwszy → ostatni zapis',
+        'adv.col.helper': 'Pomocnik',
+        'adv.col.asked': 'O co go poproszono',
+        'adv.col.touched': 'Dotknięte pliki',
+        'adv.col.actions': 'Działania',
+        'adv.needs': 'Do zrobienia · {n}',
+        'adv.fixed': 'Naprawione · {n}',
+        'adv.noFiles': 'Zawartość żadnego prywatnego pliku nie dotarła do AI.',
+        'adv.hint': 'Kliknij wiersz, żeby zobaczyć każde zdarzenie dla tego pliku.',
+        'adv.status.read': 'Przeczytał prywatne pliki',
+        'adv.status.sample': 'Tylko przykładowy plik',
+        'adv.status.named': 'Widział tylko nazwę',
+        'adv.status.unknown': 'Brak zapisu',
+        'adv.status.stopped': 'Zatrzymany',
+        'adv.status.none': 'Nic prywatnego',
+        'rp.gap.banner': 'Brakuje części zapisu tej rozmowy, więc ta lista może być niepełna.',
+        'rp.gap.link': 'Zobacz, czego brakuje →',
+        'rp.gap.fact': 'Nie widzimy nic do naprawy.',
+        'rp.gap.action': 'Ale brakuje części zapisu.',
+        'rp.gap.stopped': 'Twoja ochrona zadziałała.',
+        'rp.gap.body': 'Brakuje części zapisu tej rozmowy. Brak dowodów to nie to samo, co brak zdarzeń.',
+        'adv.tab.record': 'Zapis',
+        // 2026-09-27-what-codex-wrote.md X23, X19-X22: czego zapis Codexa nie pokaże i co wtedy zapisał.
+        'rp.gap.codex.action': 'Ale Codex nie zapisuje każdego kroku.',
+        'rp.gap.codex.legacyAction': 'Ale Codex nie zapisał swoich poleceń.',
+        'rp.gap.codex.lead': 'Codex nie zapisuje każdego kroku, więc ten raport może nie pokazywać wszystkiego, co otworzył.',
+        'rp.gap.codex.body': 'Zapisuje większość tego, co robi. Oto, co zapisał.',
+        'rp.gap.codex.legacy': 'Codex zapisał tę rozmowę w starszy sposób, który nie pokazuje, jakie polecenia uruchomił. Oto, co zapisał.',
+        'rp.gap.codex.banner': 'Codex nie zapisuje każdego kroku, więc na tej liście może czegoś brakować.',
+        'rec.recorded': 'Co {ai} zapisał w trakcie',
+        'rec.recorded.note': 'To ustawienia, które {ai} miał podczas rozmowy. To nie są Twoje zasady agentwhy: ten raport sprawdza Twoje prywatne pliki według ustawień z teraz.',
+        'rec.perm.turns.one': '{n} tura',
+        'rec.perm.turns.few': '{n} tury',
+        'rec.perm.turns.many': '{n} tur',
+        'rec.perm.approval': 'pyta przed działaniem: {value}',
+        'rec.perm.approver': 'odpowiada: {value}',
+        'rec.perm.sandbox': 'piaskownica: {value}',
+        'rec.perm.network': 'sieć: {value}',
+        'rec.perm.scopes': 'może czytać w {read} i pisać w {write} miejscach',
+        'rec.perm.writable': 'Może pisać w',
+        'rec.perm.incomplete': 'Części nie zrozumieliśmy, więc ją pominięto.',
+        'rec.who.person': 'Ty',
+        'rec.who.reviewer': 'recenzent, którego uruchamia {ai}',
+        'rec.who.unrecognised': 'nie wiadomo',
+        'rec.who.unrecorded': 'nie zapisano',
+        'rec.net.allowed': 'włączona',
+        'rec.net.restricted': 'wyłączona',
+        'rec.net.unrecognised': 'nie wiadomo',
+        'rec.net.unrecorded': 'nie zapisano',
+        'rec.value.none': 'nie zapisano',
+        'rec.reviews': 'Co zdecydował recenzent, którego uruchamia {ai}',
+        'rec.review.allowed': 'Zezwolił na działanie w jednej z tur ({who}). Nie zapisano, na które działanie.',
+        'rec.review.allowedNoTurn': 'Zezwolił na działanie, w żadnej turze, którą wskazuje zapis.',
+        'rec.review.unrecognised': 'Dał odpowiedź, której nie znamy. Nie traktujemy jej jako odmowy.',
+        'rec.review.risk': 'ryzyko: {risk}',
+        'rec.review.why.one': 'uzasadnienie: {n} znak, niepokazane',
+        'rec.review.why.few': 'uzasadnienie: {n} znaki, niepokazane',
+        'rec.review.why.many': 'uzasadnienie: {n} znaków, niepokazane',
+        'rec.q.actions': 'jakie działania się odbyły',
+        'rec.q.access': 'do czego dotarło działanie',
+        'rec.q.output-delivery': 'co dotarło do Twojego AI',
+        'rec.q.own-words': 'wszystko, co napisało Twoje AI',
+        'rec.q.reasoning': 'co Twoje AI ustaliło przed działaniem',
+        'rec.q.refusals': 'czy działanie zostało zatrzymane',
+        'rec.q.permissions': 'jakie uprawnienia obowiązywały',
+        'rec.shapes': 'Kształty kluczy w wynikach',
+        'rec.shapes.none': 'Żaden wynik nie zawierał niczego w kształcie klucza.',
+        'rec.gap.title.gaps': 'Części tej rozmowy nie ma w zapisie',
+        'rec.gap.lead.gaps': 'Wszystko, co pokazuje raport, jest w zapisie. Ale czegoś w nim brakuje, więc raport może nie pokazywać wszystkiego: pusta lista nie znaczy, że nic się nie stało.',
+        'rec.gap.title.clean': 'Zapis tej rozmowy jest pełny',
+        'rec.gap.lead.clean': 'Nie znaleźliśmy w nim braków, więc ten raport opiera się na całej rozmowie.',
+        'rec.gap.tag.gaps': 'Ma luki',
+        'rec.gap.tag.clean': 'Pełny',
+        'rec.gap.missing': 'Czego brakuje w zapisie',
+        'rec.gap.times.one': 'raz',
+        'rec.gap.times.few': '{n} razy',
+        'rec.gap.times.many': '{n} razy',
+        'rec.gap.times.other': '{n} razy',
+        'rec.gap.which': 'Pokaż które',
+        'rec.gap.k.session-missing.t': 'Nie udało się odczytać rozmowy',
+        'rec.gap.k.session-missing.d': 'Niczego w tym raporcie nie można traktować jako ustalenia.',
+        'rec.gap.k.source-missing.t': 'Brakuje części zapisu',
+        'rec.gap.k.source-missing.d': 'Jakiegoś pliku tej rozmowy - na przykład pomocnika - nie było albo nie dało się go odczytać, więc tego, co się w nim stało, tu nie ma.',
+        'rec.gap.k.record-damaged.t': 'Uszkodzona linia',
+        'rec.gap.k.record-damaged.d': 'Jednej linii zapisu nie dało się odczytać. Mogła zostać ucięta w trakcie zapisywania.',
+        'rec.gap.k.result-missing.t': 'Działanie bez wyniku',
+        'rec.gap.k.result-missing.d': 'Twoje AI je rozpoczęło, ale w zapisie nie ma odpowiedzi, więc nie wiemy, czy się udało ani co zwróciło.',
+        'rec.gap.k.spilled-result-missing.t': 'Zaginął długi wynik',
+        'rec.gap.k.spilled-result-missing.d': 'Był zapisany w osobnym pliku, którego już nie ma.',
+        'rec.gap.k.outcome-unrecognised.t': 'Zakończenie, którego nie znamy',
+        'rec.gap.k.outcome-unrecognised.d': 'Zapis oznacza koniec działania w sposób, którego ta wersja agentwhy nie zna, więc nie zgadujemy.',
+        'rec.gap.k.relation-unresolved.t': 'Działania, których nie dało się powiązać',
+        'rec.gap.k.relation-unresolved.d': 'Nie dało się pewnie ustalić, który wynik należy do którego działania, więc nie mówimy, jak się skończyły.',
+        'rec.gap.k.result-incomplete.t': 'Tekst, który mógł zostać ucięty',
+        'rec.gap.k.result-incomplete.d': 'Możemy powiedzieć, co w nim jest, ale nie, czego w nim nie ma: brakująca część mogła zawierać więcej.',
+        'rec.gap.k.answer-unread.t': 'Nie udało się odczytać odpowiedzi pomocnika',
+        'rec.gap.k.answer-unread.d': 'Więc nie wiemy, co przekazał z powrotem Twojemu AI.',
+        'rec.gap.k.answer-awaited.t': 'Odpowiedź pomocnika nie dotarła',
+        'rec.gap.k.answer-awaited.d': 'Pracował w tle, a jego odpowiedź nigdy nie dotarła do Twojego AI.',
+        'rec.gap.unknown.t': 'Działania o nieznanym zakończeniu',
+        'rec.gap.unknown.d': 'Nie wiemy, czy się udały, czy zostały zatrzymane.',
+        'rec.gap.unresolved.t': 'Pomocnicy bez znanego zlecenia',
+        'rec.gap.unresolved.d': 'Nie wiemy, kto ich uruchomił ani o co zostali poproszeni.',
+        'rec.gap.lost.t': 'Pomocnicy, o których prosiło AI, a których nie ma w zapisie',
+        'rec.gap.lost.d': 'Twoje AI poprosiło o pomoc, ale zapisu pomocnika tu nie ma, więc nie widać, co zrobił.',
+        'rec.cap.h': 'Czego ten zapis nie pokazuje',
+        'rec.cap.lead': 'Nic się nie zepsuło: {ai} tego nie zapisuje albo jeszcze nie sprawdziliśmy, czy zapisuje. Dlatego raport nie może tego ani potwierdzić, ani wykluczyć.',
+        'rec.cap.tag.absent': 'Nie zapisuje',
+        'rec.cap.tag.unmeasured': 'Jeszcze nie sprawdzone',
+        'rec.cap.shown': '{ai} zapisuje za to: {list}.',
+        'rec.cap.t.actions': 'Jakie działania się odbyły',
+        'rec.cap.d.actions': 'Mogło ich być więcej, niż pokazuje raport.',
+        'rec.cap.t.access': 'Co otworzyło działanie',
+        'rec.cap.d.access': 'Polecenie mogło otworzyć plik, którego raport nie wymienia.',
+        'rec.cap.t.output-delivery': 'Co dotarło do Twojego AI',
+        'rec.cap.d.output-delivery': 'Nie wiemy na pewno, które wyniki Twoje AI naprawdę zobaczyło.',
+        'rec.cap.t.own-words': 'Wszystko, co napisało Twoje AI',
+        'rec.cap.d.own-words': 'Część jego wiadomości mogła nie trafić do zapisu.',
+        'rec.cap.t.reasoning': 'Co Twoje AI rozważało przed działaniem',
+        'rec.cap.d.reasoning': 'Nie pokażemy, dlaczego wybrało dany krok.',
+        'rec.cap.t.refusals': 'Czy działanie zostało zatrzymane',
+        'rec.cap.d.refusals': 'Gdy działanie zostało zatrzymane, zapis może tego nie mówić.',
+        'rec.cap.t.permissions': 'Jakie uprawnienia miało Twoje AI',
+        'rec.cap.d.permissions': 'Nie pokażemy, na co mu pozwolono.',
+        'rec.note': 'Nawet z pełnego zapisu raport nie powie, dlaczego Twoje AI coś zrobiło, co dokładnie mu polecono ani czy klucz, który zobaczyło, naprawdę wyciekł. Nazwa pliku w poleceniu liczy się jako dotknięcie - czasem to tylko wzmianka, a nie otwarcie.',
+        'rec.how.h': 'Jak sprawdziliśmy tę rozmowę',
+        'rec.how.rule': 'Co uznajemy za problem',
+        'rec.how.rule.no-read': 'Otwarcie lub przeszukanie prywatnego pliku przez Twoje AI',
+        'rec.how.rule.no-disclose': 'Przekazanie dalej czegoś z prywatnego pliku. Samo czytanie jest dozwolone.',
+        'rec.how.rule.other': 'Zasada, której ta strona nie opisuje: zobacz szczegóły techniczne',
+        'rec.how.files': 'Które pliki są prywatne',
+        'rec.how.files.builtIn': 'Wbudowana lista agentwhy: {patterns}, {exceptions}',
+        'rec.how.files.own': 'Twoja własna lista: {patterns}, {exceptions}',
+        'rec.how.files.note': 'Sprawdzone według listy z teraz, nie z chwili rozmowy. Pasująca nazwa to powód, żeby się przyjrzeć, a nie dowód, że coś wyciekło.',
+        'rec.how.paths': 'Ścieżki plików',
+        'rec.how.paths.full': 'Pokazane w całości',
+        'rec.how.paths.shared': 'Skrócone do udostępnienia',
+        'rec.how.root.known': 'Względem folderu Twojego projektu.',
+        'rec.how.root.absent': 'Dokładnie tak, jak je zapisano: zapis nie mówi, w jakim folderze jest projekt.',
+        'rec.how.root.ambiguous': 'Dokładnie tak, jak je zapisano: rozmowa pracowała w {n} folderach, więc żaden z nich nie jest jedynym folderem projektu.',
+        'rec.how.session': 'Identyfikator rozmowy',
+        'rec.how.level': 'Zasada',
+        'rec.how.origin': 'Skąd zasada',
+        'rec.runs.none': 'Żadne AI nie zrobiło nic z prywatnym plikiem, więc nie ma przebiegu do pokazania.',
+        'rec.actions.one': 'Wszystkie jego działania ({n})',
+        'rec.actions.few': 'Wszystkie jego działania ({n})',
+        'rec.actions.many': 'Wszystkie jego działania ({n})',
+        'rec.actions.other': 'Wszystkie jego działania ({n})',
+        'rec.runs.lead': 'Kroki każdego AI z prywatnymi plikami, w kolejności z zapisu.',
+        'rec.runs.key.coral': 'Miało tekst pliku',
+        'rec.runs.key.blue': 'Tylko nazwa',
+        'rec.runs.key.amber': 'Nie wiadomo',
+        'rec.runs.key.mint': 'Zatrzymane',
+        'rec.cameBack': 'Co wróciło',
+        'st.unknownYn': 'NIE WIADOMO',
+        'st.e.inResult.keys': 'Zobaczyło klucze w tym, co wypisało polecenie',
+        'st.e.inResult.data': 'Zobaczyło zawartość w tym, co wypisało polecenie',
+        'st.sub.inResult': 'Żadne polecenie nie prosiło o ten plik. Wypisało go {did}.',
+        'st.sub.lines.one': 'Wyszukiwanie wypisało 1 wiersz tego pliku, przez {did}.',
+        'st.sub.lines.few': 'Wyszukiwanie wypisało {n} wiersze tego pliku, przez {did}.',
+        'st.sub.lines.many': 'Wyszukiwanie wypisało {n} wierszy tego pliku, przez {did}.',
+        'st.sub.lines.other': 'Wyszukiwanie wypisało {n} wiersza tego pliku, przez {did}.',
+        'st.sub.inResultLines.one': 'Żadne polecenie nie prosiło o ten plik. {did} wypisało z niego 1 wiersz.',
+        'st.sub.inResultLines.few': 'Żadne polecenie nie prosiło o ten plik. {did} wypisało z niego {n} wiersze.',
+        'st.sub.inResultLines.many': 'Żadne polecenie nie prosiło o ten plik. {did} wypisało z niego {n} wierszy.',
+        'st.sub.inResultLines.other': 'Żadne polecenie nie prosiło o ten plik. {did} wypisało z niego {n} wiersza.',
+        'hp.line.empty': 'Jego działania nie zostały zapisane.',
+        'hp.answer.empty': 'Jego działania nie zostały zapisane, więc nie da się powiedzieć, co zrobił. To nie znaczy, że nic nie zrobił.',
+        'adv.status.empty': 'Brak zapisu',
+        'rp.when': 'Raport z {when}',
+        'st.col.time': 'Czas',
+        'st.rec.timesNote': 'Czas to moment zapisania każdej linii. Kolejność jest kolejnością zapisu.',
+        'hp.alone.fact': 'Twoje AI pracowało samo.',
+        'hp.alone.unsure': 'W zapisie twoje AI nie ma pomocników.',
+        'hp.alone.lead': 'Pomocnicy to dodatkowe AI, które twoje AI może wezwać, żeby pracować szybciej. Tym razem nie wezwało żadnego. Oto, co zrobiło samo.',
+        'hp.alone.unsure.lead': 'Brakuje części zapisu, więc nie możemy powiedzieć, że pracowało samo. Oto, co twoje AI zrobiło samo.',
+        'hp.alone.empty.lead': 'To nie znaczy, że nic się nie stało. To znaczy, że ten raport nie może powiedzieć, co się stało.',
+        'hp.alone.read.one': 'Przeczytało {n} prywatny plik.',
+        'hp.alone.read.few': 'Przeczytało {n} prywatne pliki.',
+        'hp.alone.read.many': 'Przeczytało {n} prywatnych plików.',
+        'hp.alone.read.other': 'Przeczytało {n} prywatnego pliku.',
+        'hp.alone.sample.one': 'Widziało tylko przykładowy plik.',
+        'hp.alone.sample.few': 'Widziało tylko przykładowe pliki.',
+        'hp.alone.sample.many': 'Widziało tylko przykładowe pliki.',
+        'hp.alone.sample.other': 'Widziało tylko przykładowe pliki.',
+        'hp.alone.named.one': 'Widziało tylko nazwę prywatnego pliku.',
+        'hp.alone.named.few': 'Widziało tylko nazwy {n} prywatnych plików.',
+        'hp.alone.named.many': 'Widziało tylko nazwy {n} prywatnych plików.',
+        'hp.alone.named.other': 'Widziało tylko nazwy {n} prywatnych plików.',
+        'hp.alone.unknown': 'Próbowało otworzyć prywatny plik. Zapis nie mówi, co się stało.',
+        'hp.alone.stopped': 'Próbowało otworzyć prywatny plik. Zostało zatrzymane w porę.',
+        'hp.alone.none': 'Nie dotknęło niczego prywatnego.',
+        'hp.alone.empty': 'Jego własne działania też nie zostały zapisane.',
+        'rp.clean.seeFiles': 'Zobacz każdy plik, który otworzyło',
+        'rp.clean.stopped.one': 'Próbowało otworzyć {n} prywatny plik. Zostało zatrzymane w porę.',
+        'rp.clean.stopped.few': 'Próbowało otworzyć {n} prywatne pliki. Zostało zatrzymane w porę.',
+        'rp.clean.stopped.many': 'Próbowało otworzyć {n} prywatnych plików. Zostało zatrzymane w porę.',
+        'rp.clean.stopped.other': 'Próbowało otworzyć {n} prywatnego pliku. Zostało zatrzymane w porę.',
+        'rp.clean.stoppedLine': 'Twoja ochrona zadziałała. Nie ma nic do zrobienia.',
+        'rp.clean.unknown.one': 'Próbowało otworzyć {n} prywatny plik.',
+        'rp.clean.unknown.few': 'Próbowało otworzyć {n} prywatne pliki.',
+        'rp.clean.unknown.many': 'Próbowało otworzyć {n} prywatnych plików.',
+        'rp.clean.unknown.other': 'Próbowało otworzyć {n} prywatnego pliku.',
+        'rp.clean.unknownLine': 'Zapis nie mówi, co się stało.',
+        'rp.clean.helpers.one': 'Skorzystało z {n} pomocnika.',
+        'rp.clean.helpers.few': 'Skorzystało z {n} pomocników.',
+        'rp.clean.helpers.many': 'Skorzystało z {n} pomocników.',
+        'rp.clean.helpers.other': 'Skorzystało z {n} pomocnika.',
+        'rp.clean.helpersClean.one': 'Nie przeczytał twoich prywatnych plików.',
+        'rp.clean.helpersClean.few': 'Żaden z nich nie przeczytał twoich prywatnych plików.',
+        'rp.clean.helpersClean.many': 'Żaden z nich nie przeczytał twoich prywatnych plików.',
+        'rp.clean.helpersClean.other': 'Żaden z nich nie przeczytał twoich prywatnych plików.',
+        'rp.clean.helpersUnknown.one': 'Nie wszystko, co zrobił, zostało zapisane.',
+        'rp.clean.helpersUnknown.few': 'Nie wszystko, co zrobili, zostało zapisane.',
+        'rp.clean.helpersUnknown.many': 'Nie wszystko, co zrobili, zostało zapisane.',
+        'rp.clean.helpersUnknown.other': 'Nie wszystko, co zrobili, zostało zapisane.',
+        'rp.clean.seeHelpers': 'Zobacz przebieg',
+        'rp.clean.record': 'Zobacz pełny zapis',
+        'rp.nothing.fact': 'Wszystko w porządku.',
+        'rp.nothing.action': 'Nie ma nic do naprawy.',
+        'rp.nothing.back': 'Gotowe — wróć do rozmów',
+        'rp.asked': 'O co prosiłeś',
+        'rp.clean.heading': 'Co się stało',
+        'rp.clean.private': 'Nie otworzyło żadnego prywatnego pliku.',
+        'rp.clean.privateTag': 'Żadnego',
+        'rp.clean.privateLine': 'Twoje hasła, klucze i dane klientów pozostały zamknięte.',
+        'rp.clean.privateShape': 'Żaden plik oznaczony jako prywatny nie został otwarty. Ostrzeżenie powyżej dotyczy czegoś w wyniku.',
+        'rp.clean.allowed.one': 'Przeczytało {n} prywatny plik, na który mu pozwoliłeś.',
+        'rp.clean.allowed.few': 'Przeczytało {n} prywatne pliki, na które mu pozwoliłeś.',
+        'rp.clean.allowed.many': 'Przeczytało {n} prywatnych plików, na które mu pozwoliłeś.',
+        'rp.clean.allowed.other': 'Przeczytało {n} prywatnego pliku, na który mu pozwoliłeś.',
+        'rp.clean.allowedLine.one': 'Wybrałeś dla niego Obserwuje, a w tym, co przeczytało, nie było klucza, który rozpoznajemy. Nie ma nic do zrobienia.',
+        'rp.clean.allowedLine.few': 'Wybrałeś dla nich Obserwuje, a w tym, co przeczytało, nie było klucza, który rozpoznajemy. Nie ma nic do zrobienia.',
+        'rp.clean.allowedLine.many': 'Wybrałeś dla nich Obserwuje, a w tym, co przeczytało, nie było klucza, który rozpoznajemy. Nie ma nic do zrobienia.',
+        'rp.clean.allowedLine.other': 'Wybrałeś dla niego Obserwuje, a w tym, co przeczytało, nie było klucza, który rozpoznajemy. Nie ma nic do zrobienia.',
+        'rp.clean.named.one': 'Widziało nazwę {n} prywatnego pliku.',
+        'rp.clean.named.few': 'Widziało nazwy {n} prywatnych plików.',
+        'rp.clean.named.many': 'Widziało nazwy {n} prywatnych plików.',
+        'rp.clean.named.other': 'Widziało nazwy {n} prywatnego pliku.',
+        'rp.clean.namedLine.one': 'Nie widziało, co jest w środku, więc nie ma nic do zrobienia.',
+        'rp.clean.namedLine.few': 'Nie widziało, co jest w środku, więc nie ma nic do zrobienia.',
+        'rp.clean.namedLine.many': 'Nie widziało, co jest w środku, więc nie ma nic do zrobienia.',
+        'rp.clean.namedLine.other': 'Nie widziało, co jest w środku, więc nie ma nic do zrobienia.',
+        'rp.clean.namedLineGap.one': 'Zapis nie pokazuje, czy widziało, co jest w środku.',
+        'rp.clean.namedLineGap.few': 'Zapis nie pokazuje, czy widziało, co jest w środku.',
+        'rp.clean.namedLineGap.many': 'Zapis nie pokazuje, czy widziało, co jest w środku.',
+        'rp.clean.namedLineGap.other': 'Zapis nie pokazuje, czy widziało, co jest w środku.',
+        'rp.clean.noHelpers': 'Pracowało samo.',
+        'rp.clean.noHelpersTag': 'Bez pomocników',
+        'rp.clean.alone': 'Nie uruchomiło żadnego innego AI do pomocy.',
+        'rp.ask.title': 'Pytania o ten raport? Zapytaj mnie.',
+        'rp.ask.name': 'Co znaczy „widziało nazwę”?',
+        'rp.ask.nameA': 'Twoje AI widziało nazwę pliku, nie to, co jest w środku.\nNazwa może pojawić się na liście plików albo w poleceniu, które nie wypisało pliku.\nNic ze środka pliku nie dotarło do twojego AI, więc nie ma nic do zmiany.',
+        'rp.ask.safe': 'Czy moje dane są bezpieczne?',
+        'rp.ask.safeA': 'Nic tu nie wskazuje, że twoje AI przeczytało prywatny plik.\nW tej rozmowie nie otworzyło żadnego pliku oznaczonego jako prywatny.\nWidzimy tylko to, co AI zapisało, nie to, co myślało.',
+        'rp.ask.safeAllowedA': 'Twoje AI przeczytało tylko prywatne pliki, na które mu pozwoliłeś. Wybrałeś dla nich Obserwuje.\nW tym, co przeczytało, nie było klucza, który rozpoznajemy, więc nie ma nic do zmiany.\nJeśli Claude Code nie powinien otwierać któregoś z nich, przełącz go na Blokuj w Ustawieniach.',
+        'rp.ask.change': 'Czy muszę coś zmienić?',
+        'rp.ask.changeA': 'Nie. Nie ma tu nic do naprawy.\nJeśli jest plik, którego twoje AI nigdy nie powinno otwierać, dodaj go do prywatnych plików. Od tej chwili każdy raport pokaże, kiedy AI do niego sięgnie.',
+        'rp.dev.title': 'Szczegóły dla programisty',
+        'rp.shape.next': 'Jeśli to prawdziwy klucz, zmień go tam, gdzie został utworzony: do tego czasu każdy, kto go ma, może go użyć.',
+        'rp.shape.link': 'Zobacz, gdzie się pojawił \u2192',
+        'fl.noneListed': 'Twoje AI nie otworzyło żadnego pliku, który umiemy wymienić.',
+        'fl.names.one': '<strong>{n} nazwa pliku, którą tylko widziało</strong> <span class="fold-rest">Nic nie wskazuje, że został otwarty albo że jest w twoim projekcie.</span>',
+        'fl.names.few': '<strong>{n} nazwy plików, które tylko widziało</strong> <span class="fold-rest">Nic nie wskazuje, że zostały otwarte albo że są w twoim projekcie.</span>',
+        'fl.names.many': '<strong>{n} nazw plików, które tylko widziało</strong> <span class="fold-rest">Nic nie wskazuje, że zostały otwarte albo że są w twoim projekcie.</span>',
+        'fl.names.other': '<strong>{n} nazwy plików, które tylko widziało</strong> <span class="fold-rest">Nic nie wskazuje, że zostały otwarte albo że są w twoim projekcie.</span>',
+        'wz.data.askHelp': 'Otwórz plik i zobacz, co w nim jest. Wybierz, co najlepiej pasuje, a pokażemy, co zrobić.',
+        'wz.data.peopleWhat': 'Imiona, e-maile, numery telefonów albo adresy prawdziwych osób - klientów, użytkowników, pracowników.',
+        'wz.data.businessWhat': 'Umowa, faktura, ceny albo plany, którymi dzielisz się tylko z niektórymi.',
+        'wz.data.otherWhat': 'Cokolwiek innego, czego nie pokazałbyś publicznie - notatki, eksporty, dane logowania, które nie są kluczami.',
+    },
+    de: {
+        'rp.title': 'Bericht · agentwhy',
+        'rp.nav.todo': 'Deine Aufgaben',
+        'rp.nav.helpers': 'Ablauf',
+        'rp.nav.files': 'Dateien',
+        'rp.nav.advanced': 'Erweitert',
+        'rp.nav.back': '← Alle Unterhaltungen',
+        'rp.hero.fact.one': 'Deine KI hat eine private Datei geöffnet.',
+        'rp.hero.fact.other': 'Deine KI hat {n} private Dateien geöffnet.',
+        'rp.hero.todo.one': 'Machen wir sie sicher.',
+        'rp.hero.todo.other': 'Machen wir sie sicher.',
+        'rp.hero.done.one': 'Du hast sie sicher gemacht.',
+        'rp.hero.done.other': 'Du hast sie sicher gemacht.',
+        'rp.hero.lead': 'Deine KI hat gelesen, was sie geöffnet hat, und hat jetzt diese Informationen. Folge den Schritten unten, eine Datei nach der anderen.',
+        'rp.guide.start': 'Nicht sicher, wo du anfangen sollst? Ich führe dich.',
+        'rp.guide.startBody': 'Eine Datei nach der anderen. Etwa 2 Minuten pro Datei.',
+        'rp.guide.go': 'Los →',
+        'rp.done.title': 'Fertig. Gut gemacht.',
+        'rp.done.keys': 'Die Schlüssel, die die KI gesehen hat, funktionieren nicht mehr.',
+        'rp.done.other': 'Du hast für jede Datei getan, was ging.',
+        'rp.todo.heading': 'Deine Aufgaben',
+        'rp.todo.progress': '{done} von {total} erledigt',
+        'rp.col.file': 'Datei',
+        'rp.col.details': 'Details',
+        'rp.col.action': 'Aktion',
+        'rp.what': 'Was passiert ist',
+        'rp.fix': 'Beheben →',
+        'rp.fixed': 'Erledigt ✓',
+        'rp.nothing.title': 'Deine KI hat in dieser Unterhaltung nichts Privates gelesen.',
+        'rp.nothing.allowed': 'Deine KI hat in dieser Unterhaltung nur private Dateien gelesen, die du ihr erlaubt hast.',
+        'rp.shape.title': 'Ein Ergebnis enthält etwas, das wie ein Passwort oder Schlüssel aussieht.',
+        'rp.shape.fact': 'Etwas sieht wie ein Schlüssel aus.',
+        'rp.shape.action': 'Prüfe, ob er echt ist.',
+        'rp.shape.body': 'Es stand in keiner Datei, die dieses Projekt schützt. Art: {kinds}.',
+        'rp.item.keys': 'Schlüssel für {providers}',
+        'rp.item.template': 'Eine Beispieldatei mit Schlüsseln',
+        'rp.item.private': 'Eine private Datei',
+        'rule.env': 'Passwörter und Schlüssel',
+        'rule.npmrc': 'Passwörter zum Installieren',
+        'rule.secrets': 'Eine Datei in einem geheimen Ordner',
+        'rule.ssh': 'Anmeldeschlüssel für Computer',
+        'provider.ai': 'Dein KI-Konto',
+        'provider.github': 'Dein Code auf GitHub',
+        'provider.gitlab': 'Dein Code auf GitLab',
+        'provider.slack': 'Deine Slack-App',
+        'provider.cloud': 'Dein Cloud-Konto',
+        'provider.google': 'Google-Dienste, die deine App nutzt',
+        'provider.payments': 'Zahlungen',
+        'provider.supabase': 'Dein Supabase-Konto',
+        'provider.npm': 'Pakete installieren und veröffentlichen',
+        'provider.servers': 'Deine Server',
+        'provider.email': 'E-Mails senden',
+        'provider.database': 'Deine Datenbank',
+        'provider.backend': 'Das Backend deiner App',
+        'provider.login': 'Die Anmeldung in deiner App',
+        'provider.hosting': 'Wo deine App online läuft',
+        'provider.dev': 'Werkzeuge, mit denen du deine App baust',
+        'provider.monitoring': 'Fehlerverfolgung und Logs',
+        'provider.analytics': 'Wie Menschen deine App nutzen',
+        'provider.sms': 'SMS und Anrufe',
+        'provider.chat': 'Dein Chatbot',
+        'provider.realtime': 'Live-Updates und Anrufe in deiner App',
+        'provider.files': 'Dateien, Bilder und Videos deiner App',
+        'provider.maps': 'Karten in deiner App',
+        'provider.search': 'Die Suche in deiner App',
+        'provider.content': 'Die Inhalte deiner Website',
+        'provider.shop': 'Dein Onlineshop',
+        'provider.social': 'Die Verbindung zu sozialen Netzwerken',
+        'provider.workspace': 'Deine Arbeitswerkzeuge',
+        'wz.keys.guess': 'Das vermuten wir nach dem Namen: {names}',
+        'wz.keys.textGuess': 'Jede Karte ist eine Website, zu der deine Schlüssel gehören. Geh dorthin, erstelle einen neuen Schlüssel und lösche den alten.',
+        'wz.file': 'Datei {n} von {total}',
+        'wz.step.keys': 'Neue Schlüssel',
+        'wz.step.app': 'Deine App',
+        'wz.step.done': 'Fertig',
+        'wz.step.limit': 'Schaden begrenzen',
+        'wz.step.stop': 'Beim nächsten Mal',
+        'wz.now': 'Jetzt behebst du',
+        'wz.context.keys.one': 'Deine KI hat die Schlüssel in {name} gelesen. Die alten Schlüssel funktionieren, bis du sie änderst.',
+        'wz.context.keys.other': '{n} KIs haben die Schlüssel in {name} gelesen. Die alten Schlüssel funktionieren, bis du sie änderst.',
+        'wz.context.data.one': 'Deine KI hat {name} gelesen. Das lässt sich nicht zurücknehmen, aber du kannst den Schaden begrenzen.',
+        'wz.context.data.other': '{n} KIs haben {name} gelesen. Das lässt sich nicht zurücknehmen, aber du kannst den Schaden begrenzen.',
+        'wz.stepOf': 'Schritt {n} von 2',
+        'wz.keys.title': 'Machen wir neue Schlüssel',
+        'wz.keys.text': 'Diese Datei hat Schlüssel für {providers}. Öffne jeden, erstelle einen neuen Schlüssel und lösche den alten.',
+        'wz.keys.textUnnamed': 'Öffne die Datei. Jede Zeile beginnt mit einem Namen - STRIPE_… ist Stripe. Geh dorthin und erstelle einen neuen Schlüssel.',
+        'wz.keys.unnamed': 'Die Schlüssel in dieser Datei',
+        'wz.keys.unnamedWhat': 'Für jeden einen neuen erstellen und die alten löschen.',
+        'wz.keys.others': 'Weitere Schlüssel in dieser Datei',
+        'wz.keys.textLines': 'Wir wissen nicht, woher diese Schlüssel stammen. Erstelle dort, woher du jeden hast, einen neuen - oder, wenn du ihn dir selbst ausgedacht hast, ändere ihn einfach.',
+        'wz.keys.lineWhat': 'Einen neuen erstellen und den alten löschen.',
+        'wz.keys.notKey': 'Kein Schlüssel, wie NODE_ENV? Einfach als erledigt markieren.',
+        'wz.context.every.one': 'Beim Öffnen einer Datei sieht deine KI jede Zeile - hier {n} Schlüssel.',
+        'wz.context.every.other': 'Beim Öffnen einer Datei sieht deine KI jede Zeile - hier {n} Schlüssel.',
+        'wz.keys.testNote': 'Dem Namen nach ein Testschlüssel - weniger dringend.',
+        'wz.keys.more.one': '1 weiteren Schlüssel zeigen',
+        'wz.keys.more.other': '{n} weitere Schlüssel zeigen',
+        'wz.keys.open.one': '1 Schlüssel wirkt öffentlich - nichts zu ändern',
+        'wz.keys.open.other': '{n} Schlüssel wirken öffentlich - nichts zu ändern',
+        'wz.keys.openWhy': 'Nach den Namen zeigen Apps diese ohnehin jedem Besucher, ein Wechsel bringt also nichts. Ist einer davon geheim, ändere ihn trotzdem.',
+        'wz.open': '{provider} öffnen',
+        'wz.app.title': 'Neue Schlüssel in deine App eintragen',
+        'wz.app.text': 'Mach das selbst — es dauert eine Minute.',
+        'wz.app.warnStrong': 'Füge die neuen Schlüssel nicht in deine KI ein.',
+        'wz.app.warn': 'Sie würde sie wieder sehen, und wir wären wieder am Anfang.',
+        'wz.app.open': 'Öffne diese Datei auf deinem Computer:',
+        'wz.copy': 'Pfad kopieren',
+        'wz.copied': 'Kopiert ✓',
+        'wz.app.lines': 'Finde diese Zeilen. Ersetze alles nach = durch deinen neuen Schlüssel:',
+        'wz.app.placeholder': 'neuen Schlüssel hier einfügen',
+        'wz.app.linesGeneric': 'Finde die Zeilen mit deinen alten Schlüsseln und ersetze jeden Schlüssel nach = durch den neuen.',
+        'wz.app.save': 'Speichere die Datei. Wenn deine App online ist, ändere dieselben Schlüssel auch dort, wo sie gehostet wird (zum Beispiel in den Einstellungen von Vercel oder Netlify).',
+        'wz.data.title': 'Schaden begrenzen',
+        'wz.data.ask': 'Was steht in dieser Datei?',
+        'wz.data.people': 'Daten von Personen (Kunden, Nutzer, Mitarbeiter)',
+        'wz.data.business': 'Ein Vertrag oder anderes Geschäftsdokument',
+        'wz.data.other': 'Etwas anderes Privates',
+        'wz.data.nothing': 'Nichts Privates darin',
+        'wz.data.text': 'Die Kopie lässt sich nicht zurückholen. Aber diese Schritte helfen.',
+        'wz.data.report': 'Prüfe, ob du es melden musst',
+        'wz.data.reportWhat': 'In der EU und im Vereinigten Königreich muss ein Datenleck mit Personendaten unter Umständen innerhalb von 72 Stunden nach Bekanntwerden der Datenschutzbehörde gemeldet werden, und die Betroffenen sind bei hohem Risiko zu informieren.',
+        'wz.data.agreement': 'Prüfe, was dein Vertrag sagt',
+        'wz.data.agreementWhat': 'Er kann verlangen, dass du die andere Seite informierst.',
+        'wz.data.team': 'Sag deinem Sicherheits- oder IT-Team Bescheid',
+        'wz.data.teamWhat': 'Sag ihnen, welche Datei deine KI gelesen hat. Sie entscheiden, was als Nächstes passiert.',
+        'wz.data.move': 'Verschiebe die Datei aus deinem Projekt',
+        'wz.data.moveWhat': 'Deine KI arbeitet in deinem Projektordner. Außerhalb davon ist die Datei für sie viel schwerer zu erreichen.',
+        'wz.stop.title': 'Damit es nicht wieder passiert',
+        'wz.stop.text': 'Schütze diese Datei. Claude Code muss dich dann fragen, bevor es sie öffnet.',
+        'wz.protect': 'Schützen →',
+        'wz.stop.honest': 'Das stoppt die offensichtlichen Versuche, nicht jeden Trick. Wenn etwas durchrutscht, siehst du es trotzdem in deinem Bericht.',
+        'wz.done.keys.title': 'Diese Datei ist jetzt sicher.',
+        'wz.done.keys.text': 'Die Schlüssel, die die KI gesehen hat, funktionieren nicht mehr.',
+        'wz.done.data.title': 'Du hast getan, was ging.',
+        'wz.done.data.text': 'Diese Datei steht auf deiner Liste als erledigt.',
+        'wz.left.one': 'Noch 1.',
+        'wz.left.other': 'Noch {n}.',
+        'wz.last': 'Das war die letzte!',
+        'wz.back': '← Zurück',
+        'wz.skip.keys': 'Keine echten Schlüssel hier',
+        'wz.skip.data': 'Nichts Privates darin',
+        'wz.all': 'Fertig →',
+        'wz.tickFirst': 'Markiere zuerst jede Karte als erledigt - einfach anklicken.',
+        'wz.pickFirst': 'Wähle zuerst, was in der Datei ist.',
+        'wz.later': 'Erst mal überspringen →',
+        'wz.finish': 'Fertig ✓',
+        'wz.saving': 'Wird gespeichert…',
+        'wz.copyCommand': 'Kopieren',
+        'wz.cmd.mark': 'Diese Seite ist nicht mit agentwhy verbunden und kann das nicht speichern. Damit die Datei auf deiner Liste als erledigt bleibt, führe das in deinem Projekt aus:',
+        'wz.stop.outside': 'Diese Datei liegt außerhalb deines Projektordners, darum kann diese Seite sie nicht schützen.',
+        'wz.stop.shared': 'Das ist eine geteilte Kopie des Berichts, darum kann sie im Projekt nichts ändern.',
+        'wz.stop.told': 'Für diese Datei hast du Beobachten gewählt, also darf deine KI sie öffnen, und du wirst informiert. Soll Claude Code das nicht, stell sie in den Einstellungen auf Blockieren.',
+        'wz.nextFile': 'Nächste Datei →',
+        'wz.backToList': 'Zurück zur Liste',
+        'ask.make': 'Wie erstelle ich einen neuen {provider}-Schlüssel?',
+        'ask.makeAny': 'Wie erstelle ich einen neuen Schlüssel?',
+        'ask.makeA': 'Melde dich bei {provider} an. Schlüssel liegen meist unter Einstellungen, im Bereich API keys oder Tokens. Erstelle einen neuen und lösche dann den alten.',
+        'ask.makeAnyA': 'Sieh dir die Zeile des Schlüssels in der Datei an: Sein Name sagt meist, zu welchem Dienst er gehört. Melde dich dort an; Schlüssel liegen meist unter Einstellungen, im Bereich API keys oder Tokens.',
+        'ask.login': 'Was, wenn ich keinen Zugang habe?',
+        'ask.loginA': 'Frag die Person, die diesen Dienst für deine App eingerichtet hat — jemanden aus dem Team oder die Entwicklerin. Bis der Schlüssel geändert ist, funktioniert der alte.',
+        'ask.stop': 'Hört meine App auf zu funktionieren?',
+        'ask.stopA': 'Nur kurz. Deine App nutzt den alten Schlüssel, bis du den neuen einträgst (Schritt 2). Mach beide Schritte kurz nacheinander, dann läuft sie weiter.',
+        'ask.tell': 'Muss ich es jemandem sagen?',
+        'ask.tellA': 'Das hängt davon ab, was in der Datei steht und wo du bist. Enthält sie Personendaten, sagt der Schritt oben, was das Gesetz verlangen kann. Wenn du unsicher bist, frag dein Sicherheits- oder IT-Team.',
+        'ask.who': 'Wer kann das jetzt sehen?',
+        'ask.whoA': 'Deine KI hat es gelesen, also ist es jetzt Teil deiner Unterhaltung mit der KI. Was mit dieser Unterhaltung geschieht, hängt von deiner KI und deinen Kontoeinstellungen ab.',
+        'ask.next': 'Wie verhindere ich das beim nächsten Mal?',
+        'ask.nextA': 'Schütze die Datei (Schritt 2). Dann muss Claude Code dich fragen, bevor es sie öffnet, und jeden Versuch siehst du trotzdem in deinem Bericht.',
+        'pr.title': 'Diese Datei schützen?',
+        'pr.sentence': 'Das schützt {path}. Claude Code kann sie nicht mehr öffnen. Braucht es sie für eine Aufgabe, hält es an und fragt dich zuerst. Du kannst das jederzeit rückgängig machen.',
+        'pr.option': 'Auch jede Datei namens {name} schützen, egal wo sie im Projekt liegt.',
+        'pr.confirm': 'Ja, schützen',
+        'pr.done': 'Geschützt ✓',
+        'pr.cmd': 'Diese Seite ist nicht mit agentwhy verbunden und kann die Datei nicht selbst schützen. Führe das in deinem Projekt aus:',
+        'mp.title': 'Diese Datei als privat markieren?',
+        'mp.sentence': 'Das fügt {path} deinen privaten Dateien hinzu, in deinen Einstellungen. Claude Code kann sie nicht mehr öffnen. Braucht es sie für eine Aufgabe, hält es an und fragt dich zuerst. Du kannst das jederzeit rückgängig machen.',
+        'mp.option': 'Auch jede Datei namens {name} als privat markieren, egal wo sie im Projekt liegt.',
+        'mp.confirm': 'Ja, als privat markieren',
+        'mp.cmd': 'Diese Seite ist nicht mit agentwhy verbunden und kann deine Einstellungen nicht selbst ändern. Führe das in deinem Projekt aus:',
+        'st.heading': 'Was mit dieser Datei passiert ist',
+        'st.summary.keys.one': 'Deine KI hat die Schlüssel in dieser Datei gelesen — und hat sie jetzt.',
+        'st.summary.keys.other': '{n} KIs haben die Schlüssel in dieser Datei gelesen — und haben sie jetzt.',
+        'st.summary.keysHelper': 'Ein Helfer hat die Schlüssel in dieser Datei gelesen — und hat sie jetzt.',
+        'st.summary.data.one': 'Deine KI hat diese Datei gelesen — und hat jetzt diese Informationen.',
+        'st.summary.data.other': '{n} KIs haben diese Datei gelesen — und haben jetzt diese Informationen.',
+        'st.summary.dataHelper': 'Ein Helfer hat diese Datei gelesen — und hat jetzt diese Informationen.',
+        'st.summary.reached': 'Etwas aus dieser Datei hat deine KI erreicht — und sie hat jetzt diese Informationen.',
+        'st.tab.story': 'Der Ablauf',
+        'st.tab.diagram': 'Diagramm',
+        'st.tab.record': 'Vollständiges Protokoll',
+        'st.you': 'Du',
+        'st.main': 'Deine KI',
+        'st.mainLower': 'deine KI',
+        'st.helper': 'Helfer {ordinal}',
+        'st.company': 'Es wurde offengelegt',
+        'st.e.read.keys': 'Hat die Datei geöffnet und die Schlüssel gelesen',
+        'st.e.read.data': 'Hat die Datei geöffnet und gelesen',
+        'st.e.received.keys': 'Hat die Schlüssel in dem gelesen, was ihr Programm zurückgab',
+        'st.e.received.data': 'Hat sie in dem gelesen, was ihr Programm zurückgab',
+        'st.e.again': 'Hat sie noch einmal gelesen',
+        'st.e.helperRead.keys': 'Ein Helfer hat die Schlüssel gelesen',
+        'st.e.helperRead.data': 'Ein Helfer hat sie gelesen',
+        'st.e.helperReadToo.keys': 'Auch ein Helfer hat die Schlüssel gelesen',
+        'st.e.helperReadToo.data': 'Auch ein Helfer hat sie gelesen',
+        'st.e.named': 'Hat ihren Namen gesehen',
+        'st.e.unknown': 'Hat versucht, sie zu öffnen',
+        'st.e.stopped': 'Hat versucht, sie zu öffnen. Es wurde gestoppt.',
+        'st.e.passed': 'Hat das Gelesene an {to} zurückgegeben',
+        'st.e.saved': 'Hat eine Kopie gespeichert',
+        'st.e.handed': 'Hat es an einen Helfer weitergegeben',
+        'st.e.repeated': 'Hat es in einer Nachricht wiederholt',
+        'st.e.used': 'Hat es benutzt, um etwas auszuführen',
+        'st.e.company': 'Die KI hat jetzt diese Informationen',
+        'st.sub.did': 'Mit {did}.',
+        'st.sub.received': 'Ein kleines Programm, das sie geschrieben hat, gab ihr denselben Text wie in dieser Datei zurück.',
+        'st.sub.didTimes.one': 'Mit {did}.',
+        'st.sub.didTimes.other': '{n}-mal, mit {did}.',
+        'st.sub.asked': 'Es sollte „{task}“.',
+        'st.sub.notAsked': 'Das Protokoll sagt nicht, worum es gebeten wurde.',
+        'st.sub.unknown': 'Das Protokoll sagt nicht, was passiert ist.',
+        'st.sub.passed': 'Was es zurückgeschickt hat, enthielt etwas aus dieser Datei.',
+        'st.sub.saved': 'In {files}.',
+        'st.sub.savedAny': 'Eine andere Datei hat etwas aus dieser bekommen.',
+        'st.sub.handed': 'Seine Anweisungen an einen Helfer enthielten etwas aus dieser Datei.',
+        'st.sub.repeated': 'Seine eigenen Worte enthielten etwas aus dieser Datei.',
+        'st.sub.used': 'In {programs}.',
+        'st.sub.usedAny': 'Ein Befehl oder ein Werkzeug hat etwas aus dieser Datei bekommen.',
+        'st.sub.company': 'Alles oben ist jetzt in deiner Unterhaltung mit der KI.',
+        'st.stat.opened': 'Wie oft geöffnet',
+        'st.stat.readers': 'KIs, die sie gelesen haben',
+        'st.stat.stopped': 'Rechtzeitig gestoppt',
+        'st.stat.record': 'Protokoll',
+        'st.complete': 'Vollständig',
+        'st.gaps': 'Hat Lücken',
+        'st.rec.every': 'Jedes Mal, wenn sie geöffnet wurde',
+        'st.rec.count.one': '{n} Ereignis · der Reihe nach',
+        'st.rec.count.other': '{n} Ereignisse · der Reihe nach',
+        'st.col.n': '#',
+        'st.col.who': 'Wer',
+        'st.col.what': 'Was passiert ist',
+        'st.col.tool': 'Werkzeug',
+        'st.col.result': 'Ergebnis',
+        'st.col.evidence': 'Beleg',
+        'st.res.succeeded': 'erfolgreich',
+        'st.res.blocked': 'gestoppt',
+        'st.res.unknown': 'nicht protokolliert',
+        'st.rec.each': 'Was jede KI damit gemacht hat',
+        'st.rec.yes': 'JA = ist passiert',
+        'st.col.role': 'Rolle',
+        'st.col.read': 'Gelesen',
+        'st.col.passed': 'Weitergegeben',
+        'st.col.saved': 'Kopie gespeichert',
+        'st.col.repeated': 'Wiederholt',
+        'st.col.used': 'In einem Befehl benutzt',
+        'st.col.actions': 'Aktionen',
+        'st.role.main': 'Die KI, mit der du gesprochen hast',
+        'st.role.helper': 'Hinzugeholt von: {who}',
+        'st.role.helperAny': 'Zur Hilfe hinzugeholt',
+        'st.yes': 'JA',
+        'st.no': 'NEIN',
+        'st.rec.details': 'Details zur Datei',
+        'st.fact.path': 'Vollständiger Pfad',
+        'st.fact.rule': 'Passende Regel',
+        'st.fact.why': 'Warum sie privat ist',
+        'st.fact.session': 'Sitzung',
+        'st.fact.complete': 'Protokoll vollständig?',
+        'st.why.env': 'Solche Dateien enthalten meist Schlüssel und Passwörter.',
+        'st.why.npmrc': 'Sie enthält meist das Passwort zum Installieren der Pakete deiner App.',
+        'st.why.secrets': 'Sie liegt in einem Ordner für Geheimnisse.',
+        'st.why.ssh': 'Mit solchen Schlüsseln kann sich jemand an deinen Computern anmelden.',
+        'st.why.other': 'Eine Regel für dieses Projekt markiert sie als privat.',
+        'st.complete.yes': 'Ja — nichts fehlt',
+        'st.complete.no': 'Nein — ein Teil des Protokolls fehlt',
+        'st.d.asked': 'um Hilfe gebeten',
+        'st.d.hint': 'Fahre über ein Feld, um zu sehen, wohin seine Linien führen.',
+        'st.d.file': 'deine private Datei',
+        'st.d.company': 'die KI hat diese Informationen',
+        'st.d.readKeys': 'hat die Schlüssel gelesen',
+        'st.d.readIt': 'hat sie gelesen',
+        'st.d.passed': 'hat es zurückgegeben',
+        'st.d.saved': 'hat eine Kopie gespeichert',
+        'st.d.stopped': 'wurde gestoppt',
+        'st.d.named': 'hat den Namen gesehen',
+        'st.d.times': '{n}×',
+        'st.d.legendRead': 'gelesen / Kopie gesendet',
+        'st.d.legendWork': 'Arbeit übergeben',
+        'st.foot': 'Wir sehen nur, was die KI aufgeschrieben hat, nicht was sie gedacht hat.',
+        'hp.eyebrow': 'Hinter den Kulissen',
+        'hp.fact.one': 'Deine KI hat sich von {n} Helfer helfen lassen.',
+        'hp.fact.other': 'Deine KI hat sich von {n} Helfern helfen lassen.',
+        'hp.some.one': 'Nur {n} davon hat deine privaten Dateien gelesen.',
+        'hp.some.other': 'Nur {n} davon haben deine privaten Dateien gelesen.',
+        'hp.all.one': 'Er hat deine privaten Dateien gelesen.',
+        'hp.all.other': 'Alle haben deine privaten Dateien gelesen.',
+        'hp.noneRead': 'Keiner davon hat deine privaten Dateien gelesen.',
+        'hp.lead': 'Helfer sind zusätzliche KIs, die deine KI hinzuholt, um schneller zu arbeiten. Hier siehst du, wer deine privaten Dateien gesehen hat.',
+        'hp.tab.list': 'Liste',
+        'hp.tab.diagram': 'Diagramm',
+        'hp.line.read.one': 'Hat {n} private Datei gelesen',
+        'hp.line.read.other': 'Hat {n} private Dateien gelesen',
+        'hp.line.sample': 'Hat nur eine Beispieldatei gesehen.',
+        'hp.line.named': 'Hat nur den Namen einer Datei gesehen.',
+        'hp.line.unknown': 'Hat versucht, eine private Datei zu öffnen. Das Protokoll sagt nicht, was passiert ist.',
+        'hp.line.stopped': 'Hat versucht, eine private Datei zu öffnen. Es wurde gestoppt.',
+        'hp.line.none': 'Hat nichts Privates angefasst.',
+        'hp.seeWhat': 'Was genau →',
+        'hp.safe.one': '<strong>{n} weiterer Helfer</strong> <span class="fold-rest">hat nichts Echtes gesehen.</span>',
+        'hp.safe.other': '<strong>{n} weitere Helfer</strong> <span class="fold-rest">haben nichts Echtes gesehen.</span>',
+        'hp.col.start': 'Start',
+        'hp.col.main': 'Deine KI',
+        'hp.col.helpers': 'Helfer',
+        'hp.col.files': 'Dateien',
+        'hp.key.read': 'Gelesen',
+        'hp.key.named': 'Nur den Namen gesehen',
+        'hp.key.stopped': 'Gestoppt',
+        'hp.key.work': 'Arbeit gegeben',
+        'hp.you.sub': 'Hat die Arbeit angefragt',
+        'hp.file.named': 'Nur der Name wurde gesehen',
+        'hp.file.unknown': 'Nicht protokolliert, was passiert ist',
+        'hp.file.stopped': 'Rechtzeitig gestoppt',
+        'hp.hint': 'Fahre über ein Feld, um seine Linien zu sehen. Klicke, um die Details zu öffnen.',
+        'hp.job': 'Seine Aufgabe',
+        'hp.mainJob': 'Die Arbeit, um die du in diesem Gespräch gebeten hast.',
+        'hp.opened': 'Hat er eine private Datei geöffnet?',
+        'hp.yes': 'Ja',
+        'hp.no': 'Nein',
+        'hp.answer.read': 'Er hat gelesen, was in diesen Dateien steht:',
+        'hp.answer.sample': 'Er hat den Namen einer Beispieldatei gesehen, aber nichts zeigt, dass er hineingeschaut hat.',
+        'hp.answer.named': 'Er hat den Namen einer privaten Datei gesehen, aber nichts zeigt, dass er hineingeschaut hat.',
+        'hp.answer.unknown': 'Er hat versucht, eine private Datei zu öffnen, und das Protokoll sagt nicht, was passiert ist.',
+        'hp.answer.stopped': 'Er hat versucht, eine private Datei zu öffnen. Er wurde rechtzeitig gestoppt.',
+        'hp.answer.none': 'Er hat sich von deinen privaten Dateien ferngehalten.',
+        'hp.next': 'Was er danach getan hat',
+        'hp.next.passed': 'An eine andere KI weitergegeben',
+        'hp.next.saved': 'Eine Kopie gespeichert',
+        'hp.next.repeated': 'In einer Nachricht wiederholt',
+        'hp.next.used': 'Benutzt, um etwas auszuführen',
+        'hp.explain': '✦ In einfachen Worten erklären',
+        'hp.ex.brought': '{who} hat ihn zur Hilfe hinzugeholt.',
+        'hp.ex.read': 'Er hat {files} gelesen.',
+        'hp.ex.passed': 'Etwas daraus ging weiter an eine andere KI.',
+        'hp.ex.saved': 'Er hat etwas daraus in eine andere Datei gespeichert.',
+        'hp.ex.repeated': 'Er hat etwas daraus in eigenen Worten wiederholt.',
+        'hp.ex.used': 'Er hat etwas daraus benutzt, um einen Befehl auszuführen.',
+        'hp.ex.company': 'Alles, was er gelesen hat, ist jetzt in deiner Unterhaltung mit der KI.',
+        'hp.fix': 'Diese Dateien beheben →',
+        'fl.eyebrow': 'Alles, was sie geöffnet hat',
+        'fl.fact.one': 'Deine KI hat {n} Datei geöffnet.',
+        'fl.fact.other': 'Deine KI hat {n} Dateien geöffnet.',
+        'fl.some.one': 'Nur {n} war privat.',
+        'fl.some.other': 'Nur {n} waren privat.',
+        'fl.all.one': 'Sie war privat.',
+        'fl.all.other': 'Alle waren privat.',
+        'fl.noneRead': 'Keine davon war privat.',
+        'fl.lead': 'Der Rest waren normale Arbeitsdateien. Dort ist nichts zu tun.',
+        'fl.leadAll': 'Jede steht unten, mit dem, was zu tun ist.',
+        'fl.leadNone': 'Es waren normale Arbeitsdateien. Dort ist nichts zu tun.',
+        'fl.search': 'Datei finden',
+        'fl.group.all': 'Alle Dateien',
+        'fl.group.fix': 'Zu beheben',
+        'fl.group.fixed': 'Schon behoben',
+        'fl.did.q': 'Was die KI getan hat:',
+        'fl.did.any': 'Egal',
+        'fl.did.read': 'Geöffnet und gelesen',
+        'fl.did.name': 'Nur den Namen gesehen',
+        'fl.did.stopped': 'Wurde gestoppt',
+        'fl.prot.q': 'Private Datei:',
+        'fl.prot.any': 'Egal',
+        'fl.prot.no': 'Nicht blockiert',
+        'fl.prot.yes': 'Blockiert',
+        'fl.prot.na': 'Nicht privat',
+        'fl.prot.told': 'Beobachten',
+        'fl.clear': 'Filter zurücksetzen',
+        'fl.col.file': 'Datei',
+        'fl.col.ai': 'KI',
+        'fl.col.prot': 'Private Datei',
+        'fl.col.mode': 'Wenn deine KI darauf zugreift',
+        'fl.col.action': 'Aktion',
+        'fl.acc.read': 'Gelesen',
+        'fl.acc.name': 'Nur Name',
+        'fl.acc.unknown': 'Nicht protokolliert',
+        'fl.acc.stopped': 'Gestoppt',
+        'fl.acc.changed': 'Geändert',
+        'fl.tag.private': 'Privat',
+        'fl.tag.na': 'Nicht privat',
+        'fl.mode.yes': 'Blockiert',
+        'fl.mode.told': 'Beobachten',
+        'fl.mode.no': 'Nicht blockiert',
+        'fl.mode.unknown': 'Unklar',
+        'fl.mode.na': 'Nicht nötig',
+        'fl.act.fix': 'Beheben →',
+        'fl.act.fixed': 'Behoben ✓',
+        'fl.act.none': 'Nichts zu tun',
+        'fl.protect': 'Schützen →',
+        'fl.makePrivate': 'Als privat markieren →',
+        'fl.tier.read': 'Private Dateien, die deine KI gelesen hat',
+        'fl.tier.name': 'Private Dateien, von denen sie nur den Namen gesehen hat',
+        'fl.tier.rest': 'Alles andere',
+        'fl.shown': '{shown} von {n} Dateien angezeigt.',
+        'fl.commands': 'Dateien, die deine KI nur über einen Befehl erreicht hat, stehen hier, wenn sie privat sind.',
+        'fl.noMatch': 'Keine Datei passt.',
+        'fl.kind.aiNotes': 'Notizen für die KI',
+        'fl.kind.notes': 'Notizen zu deiner App',
+        'fl.kind.settings': 'App-Einstellungen',
+        'fl.kind.code': 'Teil deiner App',
+        'fl.kind.file': 'Eine Datei',
+        'fl.w.did': 'Was die KI getan hat',
+        'fl.w.prot': 'Geschützt?',
+        'fl.w.next': 'Was zu tun ist',
+        'fl.w.did.read': 'Deine KI hat diese Datei geöffnet und gelesen, was darin steht.',
+        'fl.w.did.name': 'Deine KI hat den Namen dieser Datei gesehen, aber nichts zeigt, dass sie den Inhalt gelesen hat.',
+        'fl.w.did.unknown': 'Deine KI hat versucht, diese Datei zu öffnen, und das Protokoll sagt nicht, was passiert ist.',
+        'fl.w.did.stopped': 'Deine KI hat versucht, diese Datei zu öffnen. Sie wurde rechtzeitig gestoppt.',
+        'fl.w.did.everydayRead': 'Deine KI hat diese Datei geöffnet und gelesen.',
+        'fl.w.did.changed': 'Deine KI hat diese Datei geändert.',
+        'fl.w.did.everydayStopped': 'Deine KI hat versucht, mit dieser Datei zu arbeiten, und jeder Versuch wurde abgelehnt.',
+        'fl.w.prot.yes': 'Geschützt. Claude Code kann sie nicht öffnen, ohne dich vorher zu fragen.',
+        'fl.w.prot.no': 'Nicht geschützt. Claude Code kann sie jederzeit öffnen.',
+        'fl.w.prot.unknown': 'Wir konnten die Einstellungen deines Projekts nicht lesen, darum lässt sich das nicht sagen.',
+        'fl.w.prot.na': 'Eine normale Arbeitsdatei. Keine Regel markiert sie als privat, darum braucht sie keinen Schutz.',
+        'fl.w.prot.told': 'Du hast Beobachten gewählt: Deine KI darf sie öffnen, und du wirst informiert, wenn sie es tut.',
+        'fl.w.next.safe': 'Nichts zu tun. Diese Datei ist sicher.',
+        'fl.w.next.maybe': 'Nichts zu tun. Wenn Claude Code sie nie öffnen soll, schütze sie.',
+        'fl.w.next.none': 'Nichts zu tun.',
+        'fl.w.next.told': 'Nichts zu tun. Soll Claude Code sie nie öffnen, stell sie in den Einstellungen auf Blockieren.',
+        'adv.eyebrow': 'Erweitert',
+        'adv.title': 'Das vollständige Protokoll',
+        'adv.lead': 'Für Entwickler. Jede private Datei und jeder Helfer, mit den benutzten Werkzeugen und den Belegen dahinter.',
+        'adv.tab.files': 'Private Dateien',
+        'adv.tab.helpers': 'Helfer',
+        'adv.stat.files': 'Gelesene private Dateien',
+        'adv.stat.ais': 'Beteiligte KIs',
+        'adv.stat.events': 'Protokollierte Ereignisse',
+        'adv.stat.fixed': 'Behoben',
+        'adv.col.file': 'Datei',
+        'adv.col.readBy': 'Gelesen von',
+        'adv.col.access': 'Zugriff',
+        'adv.col.tools': 'Werkzeuge',
+        'adv.col.events': 'Ereignisse',
+        'adv.col.firstLast': 'Erster → letzter Eintrag',
+        'adv.col.helper': 'Helfer',
+        'adv.col.asked': 'Worum er gebeten wurde',
+        'adv.col.touched': 'Berührte Dateien',
+        'adv.col.actions': 'Aktionen',
+        'adv.needs': 'Zu erledigen · {n}',
+        'adv.fixed': 'Behoben · {n}',
+        'adv.noFiles': 'Der Inhalt keiner privaten Datei hat eine KI erreicht.',
+        'adv.hint': 'Klicke auf eine Zeile, um jedes Ereignis zu dieser Datei zu sehen.',
+        'adv.status.read': 'Private Dateien gelesen',
+        'adv.status.sample': 'Nur Beispieldatei',
+        'adv.status.named': 'Nur einen Namen gesehen',
+        'adv.status.unknown': 'Nicht protokolliert',
+        'adv.status.stopped': 'Gestoppt',
+        'adv.status.none': 'Nichts Privates',
+        'rp.gap.banner': 'Ein Teil des Protokolls dieses Gesprächs fehlt, darum kann diese Liste unvollständig sein.',
+        'rp.gap.link': 'Sehen, was fehlt →',
+        'rp.gap.fact': 'Wir sehen nichts zu beheben.',
+        'rp.gap.action': 'Aber ein Teil des Protokolls fehlt.',
+        'rp.gap.stopped': 'Dein Schutz hat gewirkt.',
+        'rp.gap.body': 'Ein Teil des Protokolls dieses Gesprächs fehlt. Keine Belege heißt nicht, dass nichts passiert ist.',
+        'adv.tab.record': 'Protokoll',
+        // 2026-09-27-what-codex-wrote.md X23, X19-X22: was ein Codex-Protokoll nicht zeigt, und was es damals aufzeichnete.
+        'rp.gap.codex.action': 'Aber Codex zeichnet nicht jeden Schritt auf.',
+        'rp.gap.codex.legacyAction': 'Aber Codex hat seine Befehle nicht aufgezeichnet.',
+        'rp.gap.codex.lead': 'Codex zeichnet nicht jeden Schritt auf, daher zeigt dieser Bericht vielleicht nicht alles, was Codex geöffnet hat.',
+        'rp.gap.codex.body': 'Codex zeichnet das meiste auf, was es tut. Hier ist, was es aufgezeichnet hat.',
+        'rp.gap.codex.legacy': 'Codex hat dieses Gespräch auf eine ältere Art gespeichert, die nicht zeigt, welche Befehle liefen. Hier ist, was es aufgezeichnet hat.',
+        'rp.gap.codex.banner': 'Codex zeichnet nicht jeden Schritt auf, daher fehlt in dieser Liste vielleicht etwas.',
+        'rec.recorded': 'Was {ai} damals aufgezeichnet hat',
+        'rec.recorded.note': 'Das sind die Einstellungen, die {ai} während des Gesprächs hatte. Es sind nicht deine agentwhy-Regeln: Dieser Bericht prüft deine privaten Dateien so, wie sie jetzt eingestellt sind.',
+        'rec.perm.turns.one': '{n} Runde',
+        'rec.perm.turns.other': '{n} Runden',
+        'rec.perm.approval': 'fragt vor dem Handeln: {value}',
+        'rec.perm.approver': 'antwortet: {value}',
+        'rec.perm.sandbox': 'Sandbox: {value}',
+        'rec.perm.network': 'Netzwerk: {value}',
+        'rec.perm.scopes': 'darf an {read} Orten lesen und an {write} schreiben',
+        'rec.perm.writable': 'Darf schreiben in',
+        'rec.perm.incomplete': 'Ein Teil wurde nicht verstanden und ist weggelassen.',
+        'rec.who.person': 'du',
+        'rec.who.reviewer': 'der Prüfer, den {ai} startet',
+        'rec.who.unrecognised': 'nicht bekannt',
+        'rec.who.unrecorded': 'nicht aufgezeichnet',
+        'rec.net.allowed': 'an',
+        'rec.net.restricted': 'aus',
+        'rec.net.unrecognised': 'nicht bekannt',
+        'rec.net.unrecorded': 'nicht aufgezeichnet',
+        'rec.value.none': 'nicht aufgezeichnet',
+        'rec.reviews': 'Was der Prüfer, den {ai} startet, entschieden hat',
+        'rec.review.allowed': 'Hat eine Aktion in einer Runde erlaubt ({who}). Welche Aktion, ist nicht aufgezeichnet.',
+        'rec.review.allowedNoTurn': 'Hat eine Aktion erlaubt, in keiner Runde, die das Protokoll nennt.',
+        'rec.review.unrecognised': 'Hat eine Antwort gegeben, die wir nicht kennen. Sie wird nicht als Ablehnung gelesen.',
+        'rec.review.risk': 'Risiko: {risk}',
+        'rec.review.why.one': 'seine Begründung: {n} Zeichen, nicht gezeigt',
+        'rec.review.why.other': 'seine Begründung: {n} Zeichen, nicht gezeigt',
+        'rec.q.actions': 'welche Aktionen liefen',
+        'rec.q.access': 'was eine Aktion erreicht hat',
+        'rec.q.output-delivery': 'was bei deiner KI ankam',
+        'rec.q.own-words': 'alles, was deine KI geschrieben hat',
+        'rec.q.reasoning': 'was deine KI vor dem Handeln überlegt hat',
+        'rec.q.refusals': 'ob eine Aktion gestoppt wurde',
+        'rec.q.permissions': 'welche Berechtigungen galten',
+        'rec.shapes': 'Schlüsselformen in Ergebnissen',
+        'rec.shapes.none': 'Kein Ergebnis enthielt etwas in Form eines Schlüssels.',
+        'rec.gap.title.gaps': 'Ein Teil dieses Gesprächs fehlt in der Aufzeichnung',
+        'rec.gap.lead.gaps': 'Alles, was dieser Bericht zeigt, steht in der Aufzeichnung. Aber es fehlt etwas darin, daher zeigt der Bericht vielleicht nicht alles: Eine leere Liste heißt nicht, dass nichts passiert ist.',
+        'rec.gap.title.clean': 'Die Aufzeichnung dieses Gesprächs ist vollständig',
+        'rec.gap.lead.clean': 'Wir haben darin keine Lücken gefunden, daher beruht dieser Bericht auf dem ganzen Gespräch.',
+        'rec.gap.tag.gaps': 'Hat Lücken',
+        'rec.gap.tag.clean': 'Vollständig',
+        'rec.gap.missing': 'Was in der Aufzeichnung fehlt',
+        'rec.gap.times.one': 'einmal',
+        'rec.gap.times.other': '{n}-mal',
+        'rec.gap.which': 'Zeigen, welche',
+        'rec.gap.k.session-missing.t': 'Das Gespräch ließ sich nicht lesen',
+        'rec.gap.k.session-missing.d': 'Nichts in diesem Bericht gilt als Befund.',
+        'rec.gap.k.source-missing.t': 'Ein Teil der Aufzeichnung fehlt',
+        'rec.gap.k.source-missing.d': 'Eine Datei dieses Gesprächs - etwa die eines Helfers - fehlte oder ließ sich nicht lesen, daher fehlt hier, was darin geschah.',
+        'rec.gap.k.record-damaged.t': 'Eine beschädigte Zeile',
+        'rec.gap.k.record-damaged.d': 'Eine Zeile der Aufzeichnung ließ sich nicht lesen. Vielleicht wurde sie beim Schreiben abgeschnitten.',
+        'rec.gap.k.result-missing.t': 'Eine Aktion ohne Ergebnis',
+        'rec.gap.k.result-missing.d': 'Deine KI hat sie gestartet, aber die Aufzeichnung enthält keine Antwort. Wir wissen nicht, ob sie geklappt hat oder was sie zurückgab.',
+        'rec.gap.k.spilled-result-missing.t': 'Ein langes Ergebnis fehlt',
+        'rec.gap.k.spilled-result-missing.d': 'Es lag in einer eigenen Datei, die es nicht mehr gibt.',
+        'rec.gap.k.outcome-unrecognised.t': 'Ein Ende, das wir nicht kennen',
+        'rec.gap.k.outcome-unrecognised.d': 'Die Aufzeichnung markiert das Ende einer Aktion auf eine Weise, die diese Version von agentwhy nicht kennt, daher raten wir nicht.',
+        'rec.gap.k.relation-unresolved.t': 'Aktionen, die sich nicht zuordnen ließen',
+        'rec.gap.k.relation-unresolved.d': 'Wir konnten nicht sicher sagen, welches Ergebnis zu welcher Aktion gehört, daher sagen wir nicht, wie sie ausgingen.',
+        'rec.gap.k.result-incomplete.t': 'Ein Text, der gekürzt sein kann',
+        'rec.gap.k.result-incomplete.d': 'Wir können sagen, was darin steht, aber nicht, was fehlt: Der fehlende Teil kann mehr enthalten haben.',
+        'rec.gap.k.answer-unread.t': 'Die Antwort eines Helfers ließ sich nicht lesen',
+        'rec.gap.k.answer-unread.d': 'Daher wissen wir nicht, was er deiner KI zurückgegeben hat.',
+        'rec.gap.k.answer-awaited.t': 'Die Antwort eines Helfers kam nie an',
+        'rec.gap.k.answer-awaited.d': 'Er arbeitete im Hintergrund, und seine Antwort kam nie bei deiner KI an.',
+        'rec.gap.unknown.t': 'Aktionen mit unbekanntem Ende',
+        'rec.gap.unknown.d': 'Wir wissen nicht, ob sie geklappt haben oder gestoppt wurden.',
+        'rec.gap.unresolved.t': 'Helfer ohne bekannten Auftrag',
+        'rec.gap.unresolved.d': 'Wir wissen nicht, wer sie hinzugeholt hat oder worum sie gebeten wurden.',
+        'rec.gap.lost.t': 'Angeforderte Helfer, die nicht in der Aufzeichnung stehen',
+        'rec.gap.lost.d': 'Deine KI hat um Hilfe gebeten, aber die Aufzeichnung des Helfers fehlt, daher wird nicht gezeigt, was er tat.',
+        'rec.cap.h': 'Was diese Aufzeichnung nicht zeigen kann',
+        'rec.cap.lead': 'Nichts ist kaputt: {ai} schreibt das nicht auf, oder wir haben noch nicht geprüft, ob es das tut. Daher kann der Bericht es weder bestätigen noch ausschließen.',
+        'rec.cap.tag.absent': 'Nicht aufgezeichnet',
+        'rec.cap.tag.unmeasured': 'Noch nicht geprüft',
+        'rec.cap.shown': '{ai} zeichnet dagegen auf: {list}.',
+        'rec.cap.t.actions': 'Welche Aktionen liefen',
+        'rec.cap.d.actions': 'Es können mehr gewesen sein, als der Bericht zeigt.',
+        'rec.cap.t.access': 'Was eine Aktion geöffnet hat',
+        'rec.cap.d.access': 'Ein Befehl kann eine Datei geöffnet haben, die der Bericht nicht nennt.',
+        'rec.cap.t.output-delivery': 'Was bei deiner KI ankam',
+        'rec.cap.d.output-delivery': 'Wir wissen nicht sicher, welche Ergebnisse deine KI wirklich gesehen hat.',
+        'rec.cap.t.own-words': 'Alles, was deine KI geschrieben hat',
+        'rec.cap.d.own-words': 'Manche ihrer Nachrichten fehlen vielleicht in der Aufzeichnung.',
+        'rec.cap.t.reasoning': 'Was deine KI vor dem Handeln überlegt hat',
+        'rec.cap.d.reasoning': 'Wir können nicht zeigen, warum sie einen Schritt gewählt hat.',
+        'rec.cap.t.refusals': 'Ob eine Aktion gestoppt wurde',
+        'rec.cap.d.refusals': 'Wurde eine Aktion gestoppt, sagt die Aufzeichnung das vielleicht nicht.',
+        'rec.cap.t.permissions': 'Welche Berechtigungen deine KI hatte',
+        'rec.cap.d.permissions': 'Wir können nicht zeigen, was sie durfte.',
+        'rec.note': 'Selbst aus einer vollständigen Aufzeichnung kann ein Bericht nicht sagen, warum deine KI etwas getan hat, was ihr alles gesagt wurde oder ob ein Schlüssel, den sie gesehen hat, wirklich abgeflossen ist. Ein Dateiname in einem Befehl zählt als erreicht - manchmal ist er nur erwähnt, nicht geöffnet.',
+        'rec.how.h': 'Wie wir dieses Gespräch geprüft haben',
+        'rec.how.rule': 'Was als Problem gilt',
+        'rec.how.rule.no-read': 'Wenn deine KI eine private Datei öffnet oder durchsucht',
+        'rec.how.rule.no-disclose': 'Wenn deine KI etwas aus einer privaten Datei weitergibt. Lesen ist erlaubt.',
+        'rec.how.rule.other': 'Eine Regel, die diese Seite nicht beschreibt: siehe technische Details',
+        'rec.how.files': 'Welche Dateien privat sind',
+        'rec.how.files.builtIn': 'Die eingebaute Liste von agentwhy: {patterns}, {exceptions}',
+        'rec.how.files.own': 'Deine eigene Liste: {patterns}, {exceptions}',
+        'rec.how.files.note': 'Geprüft nach der Liste von jetzt, nicht wie sie während des Gesprächs war. Ein passender Name ist ein Grund hinzusehen, kein Beweis, dass etwas abgeflossen ist.',
+        'rec.how.paths': 'Dateipfade',
+        'rec.how.paths.full': 'Vollständig gezeigt',
+        'rec.how.paths.shared': 'Zum Weitergeben gekürzt',
+        'rec.how.root.known': 'Relativ zum Ordner deines Projekts.',
+        'rec.how.root.absent': 'Genau wie geschrieben: Die Aufzeichnung sagt nicht, in welchem Ordner das Projekt liegt.',
+        'rec.how.root.ambiguous': 'Genau wie geschrieben: Das Gespräch arbeitete in {n} Ordnern, daher ist keiner davon allein der Projektordner.',
+        'rec.how.session': 'Gesprächs-ID',
+        'rec.how.level': 'Regel',
+        'rec.how.origin': 'Woher die Regel stammt',
+        'rec.runs.none': 'Keine KI hat etwas mit einer privaten Datei gemacht, darum gibt es keinen Ablauf zu zeigen.',
+        'rec.actions.one': 'Alle seine Aktionen ({n})',
+        'rec.actions.other': 'Alle seine Aktionen ({n})',
+        'rec.runs.lead': 'Die Schritte jeder KI mit privaten Dateien, in der Reihenfolge der Aufzeichnung.',
+        'rec.runs.key.coral': 'Hatte den Text der Datei',
+        'rec.runs.key.blue': 'Nur der Name',
+        'rec.runs.key.amber': 'Nicht bekannt',
+        'rec.runs.key.mint': 'Gestoppt',
+        'rec.cameBack': 'Was zurückkam',
+        'st.unknownYn': 'UNBEKANNT',
+        'st.e.inResult.keys': 'Hat die Schlüssel in der Ausgabe eines Befehls gesehen',
+        'st.e.inResult.data': 'Hat den Inhalt in der Ausgabe eines Befehls gesehen',
+        'st.sub.inResult': 'Kein Befehl hat nach dieser Datei gefragt. {did} hat sie ausgegeben.',
+        'st.sub.lines.one': 'Eine Suche hat 1 Zeile dieser Datei ausgegeben, mit {did}.',
+        'st.sub.lines.other': 'Eine Suche hat {n} Zeilen dieser Datei ausgegeben, mit {did}.',
+        'st.sub.inResultLines.one': 'Kein Befehl hat nach dieser Datei gefragt. {did} hat 1 Zeile daraus ausgegeben.',
+        'st.sub.inResultLines.other': 'Kein Befehl hat nach dieser Datei gefragt. {did} hat {n} Zeilen daraus ausgegeben.',
+        'hp.line.empty': 'Seine Aktionen wurden nicht protokolliert.',
+        'hp.answer.empty': 'Seine Aktionen wurden nicht protokolliert, darum lässt sich nicht sagen, was er getan hat. Das heißt nicht, dass er nichts getan hat.',
+        'adv.status.empty': 'Nicht protokolliert',
+        'rp.when': 'Bericht vom {when}',
+        'st.col.time': 'Zeit',
+        'st.rec.timesNote': 'Die Zeit ist, wann jede Zeile geschrieben wurde. Die Reihenfolge ist die des Protokolls.',
+        'hp.alone.fact': 'Deine KI hat allein gearbeitet.',
+        'hp.alone.unsure': 'Im Protokoll hat deine KI keine Helfer.',
+        'hp.alone.lead': 'Helfer sind zusätzliche KIs, die deine KI hinzuholen kann, um schneller zu arbeiten. Diesmal hat sie keinen hinzugeholt. Hier siehst du, was sie selbst getan hat.',
+        'hp.alone.unsure.lead': 'Ein Teil des Protokolls fehlt, darum können wir nicht sagen, dass sie allein gearbeitet hat. Hier siehst du, was deine KI selbst getan hat.',
+        'hp.alone.empty.lead': 'Das heißt nicht, dass nichts passiert ist. Es heißt, dass dieser Bericht nicht sagen kann, was passiert ist.',
+        'hp.alone.read.one': 'Sie hat {n} private Datei gelesen.',
+        'hp.alone.read.other': 'Sie hat {n} private Dateien gelesen.',
+        'hp.alone.sample.one': 'Sie hat nur eine Beispieldatei gesehen.',
+        'hp.alone.sample.other': 'Sie hat nur Beispieldateien gesehen.',
+        'hp.alone.named.one': 'Sie hat nur den Namen einer privaten Datei gesehen.',
+        'hp.alone.named.other': 'Sie hat nur die Namen von {n} privaten Dateien gesehen.',
+        'hp.alone.unknown': 'Sie hat versucht, eine private Datei zu öffnen. Das Protokoll sagt nicht, was passiert ist.',
+        'hp.alone.stopped': 'Sie hat versucht, eine private Datei zu öffnen. Sie wurde rechtzeitig gestoppt.',
+        'hp.alone.none': 'Sie hat nichts Privates angefasst.',
+        'hp.alone.empty': 'Auch ihre eigenen Aktionen wurden nicht protokolliert.',
+        'rp.clean.seeFiles': 'Jede geöffnete Datei ansehen',
+        'rp.clean.stopped.one': 'Sie hat versucht, {n} private Datei zu öffnen. Sie wurde rechtzeitig gestoppt.',
+        'rp.clean.stopped.other': 'Sie hat versucht, {n} private Dateien zu öffnen. Sie wurde rechtzeitig gestoppt.',
+        'rp.clean.stoppedLine': 'Dein Schutz hat gewirkt. Nichts zu tun.',
+        'rp.clean.unknown.one': 'Sie hat versucht, {n} private Datei zu öffnen.',
+        'rp.clean.unknown.other': 'Sie hat versucht, {n} private Dateien zu öffnen.',
+        'rp.clean.unknownLine': 'Das Protokoll sagt nicht, was passiert ist.',
+        'rp.clean.helpers.one': 'Sie hat {n} Helfer dazugeholt.',
+        'rp.clean.helpers.other': 'Sie hat {n} Helfer dazugeholt.',
+        'rp.clean.helpersClean.one': 'Er hat deine privaten Dateien nicht gelesen.',
+        'rp.clean.helpersClean.other': 'Keiner davon hat deine privaten Dateien gelesen.',
+        'rp.clean.helpersUnknown.one': 'Nicht alles, was er getan hat, wurde protokolliert.',
+        'rp.clean.helpersUnknown.other': 'Nicht alles, was sie getan haben, wurde protokolliert.',
+        'rp.clean.seeHelpers': 'Ablauf ansehen',
+        'rp.clean.record': 'Das ganze Protokoll ansehen',
+        'rp.nothing.fact': 'Alles gut.',
+        'rp.nothing.action': 'Nichts zu beheben.',
+        'rp.nothing.back': 'Fertig — zurück zu den Unterhaltungen',
+        'rp.asked': 'Was du gefragt hast',
+        'rp.clean.heading': 'Was passiert ist',
+        'rp.clean.private': 'Sie hat keine private Datei geöffnet.',
+        'rp.clean.privateTag': 'Keine',
+        'rp.clean.privateLine': 'Deine Passwörter, Schlüssel und Kundendaten blieben verschlossen.',
+        'rp.clean.privateShape': 'Keine als privat markierte Datei wurde geöffnet. Die Warnung oben betrifft etwas in einem Ergebnis.',
+        'rp.clean.allowed.one': 'Sie hat {n} private Datei gelesen, die du ihr erlaubt hast.',
+        'rp.clean.allowed.other': 'Sie hat {n} private Dateien gelesen, die du ihr erlaubt hast.',
+        'rp.clean.allowedLine.one': 'Du hast dafür Beobachten gewählt, und im Gelesenen war kein Schlüssel, den wir erkennen. Nichts zu tun.',
+        'rp.clean.allowedLine.other': 'Du hast dafür Beobachten gewählt, und im Gelesenen war kein Schlüssel, den wir erkennen. Nichts zu tun.',
+        'rp.clean.named.one': 'Sie hat den Namen von {n} privaten Datei gesehen.',
+        'rp.clean.named.other': 'Sie hat die Namen von {n} privaten Dateien gesehen.',
+        'rp.clean.namedLine.one': 'Sie hat nicht gesehen, was drin ist, also nichts zu tun.',
+        'rp.clean.namedLine.other': 'Sie hat nicht gesehen, was drin ist, also nichts zu tun.',
+        'rp.clean.namedLineGap.one': 'Die Aufzeichnung zeigt nicht, ob sie gesehen hat, was drin ist.',
+        'rp.clean.namedLineGap.other': 'Die Aufzeichnung zeigt nicht, ob sie gesehen hat, was drin ist.',
+        'rp.clean.noHelpers': 'Sie hat allein gearbeitet.',
+        'rp.clean.noHelpersTag': 'Keine Helfer',
+        'rp.clean.alone': 'Sie hat keine andere KI zu Hilfe geholt.',
+        'rp.ask.title': 'Fragen zu diesem Bericht? Frag mich.',
+        'rp.ask.name': 'Was heißt „den Namen gesehen“?',
+        'rp.ask.nameA': 'Deine KI hat den Namen der Datei gesehen, nicht was drin ist.\nEin Name kann in einer Dateiliste stehen oder in einem Befehl, der die Datei nicht ausgegeben hat.\nNichts aus der Datei hat deine KI erreicht, also ist nichts zu ändern.',
+        'rp.ask.safe': 'Sind meine Daten sicher?',
+        'rp.ask.safeA': 'Nichts hier zeigt, dass deine KI eine private Datei gelesen hat.\nSie hat in dieser Unterhaltung keine als privat markierte Datei geöffnet.\nWir sehen nur, was die KI aufgeschrieben hat, nicht was sie gedacht hat.',
+        'rp.ask.safeAllowedA': 'Deine KI hat nur private Dateien gelesen, die du ihr erlaubt hast. Du hast dafür Beobachten gewählt.\nIm Gelesenen war kein Schlüssel, den wir erkennen, also ist nichts zu ändern.\nWenn Claude Code eine davon nie öffnen soll, stell sie in den Einstellungen auf Blockieren.',
+        'rp.ask.change': 'Sollte ich etwas ändern?',
+        'rp.ask.changeA': 'Nein. Hier muss nichts behoben werden.\nWenn es eine Datei gibt, die deine KI nie öffnen soll, füge sie deinen privaten Dateien hinzu. Ab dann zeigt jeder Bericht, wenn deine KI sie erreicht.',
+        'rp.dev.title': 'Technische Details',
+        'rp.shape.next': 'Wenn es ein echter Schlüssel ist, ändere ihn dort, wo er erstellt wurde: bis dahin kann ihn jeder benutzen, der ihn hat.',
+        'rp.shape.link': 'Sehen, wo er auftauchte \u2192',
+        'fl.noneListed': 'Deine KI hat keine Datei geöffnet, die wir auflisten können.',
+        'fl.names.one': '<strong>{n} Dateiname, den sie nur gesehen hat</strong> <span class="fold-rest">Nichts zeigt, dass die Datei geöffnet wurde oder in deinem Projekt ist.</span>',
+        'fl.names.other': '<strong>{n} Dateinamen, die sie nur gesehen hat</strong> <span class="fold-rest">Nichts zeigt, dass die Dateien geöffnet wurden oder in deinem Projekt sind.</span>',
+        'wz.data.askHelp': 'Öffne die Datei und sieh nach, was darin steht. Wähle, was am besten passt, und wir zeigen dir, was zu tun ist.',
+        'wz.data.peopleWhat': 'Namen, E-Mails, Telefonnummern oder Adressen echter Menschen - Kunden, Nutzer, Mitarbeitende.',
+        'wz.data.businessWhat': 'Ein Vertrag, eine Rechnung, Preise oder Pläne, die du nur mit manchen teilst.',
+        'wz.data.otherWhat': 'Alles andere, was du nicht öffentlich zeigen würdest - Notizen, Exporte, Zugangsdaten, die keine Schlüssel sind.',
+    },
+};