engineering-memory 1.11.19 → 1.11.21

package/runtime/dist/src/localization/catalogue.generated.js

@@ -0,0 +1,786 @@
+export const bundledDirections = { en: 'ltr', tr: 'ltr' };
+export const bundledTexts = {
+    en: {
+        'cancelDelivery.context': 'A cancelled delivery leaves the folder reserved for this task until you say what happens to it, and a reserved folder keeps counting against the worktree limit. The branch and every commit on it stay either way.',
+        'cancelDelivery.example': 'Freeing the folder lets the next task start in it; keeping it leaves it reserved.',
+        'cancelDelivery.keep': 'Keep the folder as it is',
+        'cancelDelivery.kept': 'Nothing changes. The folder stays reserved for this task.',
+        'cancelDelivery.message': '{task} will not be delivered. What should happen to this folder?',
+        'cancelDelivery.release': 'Free the folder; the branch stays',
+        'cancelDelivery.released': 'The folder returns to the pool. Its files are left alone and the branch stays.',
+        'cancelDelivery.save': 'Save the changes and free the folder',
+        'cancelDelivery.saved': 'The uncommitted changes are written to a Git ref first, then the folder is freed. They can be restored from that ref.',
+        'cancelDelivery.uncommittedManaged': 'The folder has uncommitted changes; saving writes them to a Git ref they can be restored from.',
+        'cancelDelivery.uncommittedOwn': 'The folder has uncommitted changes; this is your own folder, so its files are never touched when it is freed.',
+        'decisionMode.approveForMe.description': 'I decide routine matters and ask you about critical ones.',
+        'decisionMode.approveForMe.label': 'Approve for me',
+        'decisionMode.ask.description': 'I ask you whenever a decision is needed.',
+        'decisionMode.ask.label': 'Ask for approval',
+        'decisionMode.autonomous.description': 'I weigh the choices against your goals and record my reasoning.',
+        'decisionMode.autonomous.label': 'Autonomous',
+        'decisionMode.context': 'This choice applies to this task; you can change it anytime.',
+        'decisionMode.example': 'For example, you can delegate a release decision or approve it yourself.',
+        'decisionMode.start': 'How should we work on this task?',
+        'decisionMode.switch': 'Which mode should we switch to?',
+        'delivery.baseContext': 'Specify the target branch explicitly. The remote default is not selected automatically.',
+        'delivery.baseMessage': 'Which branch should the PR/MR target?',
+        'delivery.baseTitle': 'Target branch',
+        'delivery.baseWrite.description': 'Target the branch you enter; merging is a separate decision.',
+        'delivery.baseWrite.label': 'Use this branch',
+        'delivery.commit.description': 'Save the changes on this local branch.',
+        'delivery.commit.label': 'Commit only',
+        'delivery.commit_push.description': 'Push this branch to the named remote repository.',
+        'delivery.commit_push.label': 'Commit and push',
+        'delivery.commit_push_draft_pr.description': 'Push the branch and open a draft that is not ready for review.',
+        'delivery.commit_push_draft_pr.label': 'Commit, push and draft PR/MR',
+        'delivery.commit_push_pr.description': 'Push the branch and open a request ready for review.',
+        'delivery.commit_push_pr.label': 'Commit, push and PR/MR',
+        'delivery.context': 'The task is verified and closed. This choice determines where the code goes; approval to publish memory does not authorize Git delivery.',
+        'delivery.defer.description': 'Keep the task closed and preserve its files without Git delivery.',
+        'delivery.defer.label': 'Keep it for now',
+        'delivery.destination': 'Branch / remote repository',
+        'delivery.example': 'Commit keeps work on the local branch. PR/MR pushes that branch and opens it for team review.',
+        'delivery.message': 'How should we deliver these changes?',
+        'forgetWorktree.context': 'A checkout that cannot be read is still counted against the worktree limit although nothing can use it; forgetting it frees that slot. No file in the folder is touched or deleted, and the branch stays.',
+        'forgetWorktree.example': 'After this, {task} no longer appears in the worktree list and the {folder} folder stays on disk exactly as it is.',
+        'forgetWorktree.forget': 'Stop tracking it; leave the files alone',
+        'forgetWorktree.forgotten': 'The record is removed and the slot is free again. The folder, its files and its branch stay untouched.',
+        'forgetWorktree.keep': 'Keep tracking it',
+        'forgetWorktree.kept': 'Nothing changes. The record stays and keeps counting against the limit.',
+        'forgetWorktree.message': 'The {folder} folder of task {task} can no longer be read as a Git checkout. Should Engineering Memory stop tracking it?',
+        'forgetWorktree.pendingDelivery': 'That task closed without its delivery being settled, so any undelivered work exists only in that folder.',
+        'gitPreferences.ask.development': 'Save {source} as the shared development branch?',
+        'gitPreferences.ask.production': 'Save {source} as the shared production branch?',
+        'gitPreferences.ask.test': 'Save {source} as the shared test branch?',
+        'gitPreferences.askNone.development': 'Record that this project has no development branch?',
+        'gitPreferences.askNone.production': 'Record that this project has no production branch?',
+        'gitPreferences.askNone.test': 'Record that this project has no test branch?',
+        'gitPreferences.context': 'These branches belong to the whole project: every member who starts a task here is offered them as the branch the task starts from. Only a project or organization administrator can change them. No branch is created, moved or deleted; only the preference is recorded.',
+        'gitPreferences.example': 'Once the development role points at origin/develop, the start form of the next task offers origin/develop as its first choice.',
+        'gitPreferences.leave': 'Leave unchanged',
+        'gitPreferences.message': 'Save the shared branch preferences of this project? Nothing is saved until you answer.',
+        'gitPreferences.save': 'Save this choice',
+        'gitPreferences.saved': 'This branch is recorded as the project default now, for every member.',
+        'gitPreferences.unchanged': 'Nothing changes. This role stays as it is and can be answered another time.',
+        'inspection.defer': 'Not now',
+        'inspection.deferDetail': 'Nothing is inspected and nothing is written. Your answer is recorded, so inspecting this source later is a new request.',
+        'inspection.example': 'When the inspection finishes, a memory record is proposed for each screen, service and flow, and you decide which of them get published.',
+        'inspection.localChanges': 'Application code will stay unchanged. Uncommitted changes will not enter shared memory.',
+        'inspection.modes.adopt': 'Start learning the existing project and its architecture?',
+        'inspection.modes.refresh': 'Start comparing project memory with the current code?',
+        'inspection.modes.rework': 'Start inspecting the existing project before planning its rework?',
+        'inspection.review': 'This approval starts the inspection. Permanent memory changes will be submitted for separate approval.',
+        'inspection.rework.preserve': 'Rework goal: preserve existing behavior.',
+        'inspection.rework.redesign': 'Rework goal: redesign the product. The target needs separate approval before implementation.',
+        'inspection.scope': 'Inspect architecture, state, services, network, data models, screens and flows.',
+        'inspection.source': 'Source',
+        'inspection.start': 'Start inspection',
+        'inspection.startDetail': 'The inspection starts now. The code stays unchanged and every record it writes comes back for your approval.',
+        'inspection.why.adopt': 'The project enters memory for the first time. The inspection reads the code at that source and works out how the project behaves.',
+        'inspection.why.refresh': 'The inspection compares the records already in memory with the code at that source and works out what changed.',
+        'inspection.why.rework': 'The rework plan can only be written once the project as it stands today is read.',
+        'move.after': 'The old repository is kept in the project history. Teammates still working in it can finish their open tasks and start new ones from the new repository. The project can be moved again later.',
+        'move.approve.description': 'The project points at this repository from now on and work can start here right away.',
+        'move.approve.label': 'Move the project here',
+        'move.ask': 'Move the project "{name}" to this repository?',
+        'move.decline.description': 'Nothing changes. The project keeps its current repository and no work can start in this folder.',
+        'move.decline.label': 'Do not move',
+        'move.example': 'After the move, a task started in this folder belongs to the same project and reads the same memory as before.',
+        'move.from': 'The project lives in',
+        'move.keeps': 'The project continues as it is: {tasks} tasks, {records} memory records and {items} work items stay with it; nothing is deleted or learned again.',
+        'move.to': 'This folder points at',
+        'move.unknown': 'address not recorded',
+        'move.why': 'The code of this project moved to another repository. This folder is not recognised as the home of the project, so no new work can start here.',
+        'onboarding.behavior.context': 'This decides what both the inspection and the plan aim at. Preserving means the screens and flows a user sees stay the same while the code underneath changes. Redesigning means the product itself changes, and the target screens, flows and contracts are approved before any implementation starts.',
+        'onboarding.behavior.example': 'If the behavior is preserved, a screen that asks for a serial number today still asks for it after the rework.',
+        'onboarding.behavior.message': 'Should the rework keep the product behaving as it does today, or redesign it?',
+        'onboarding.behavior.preserve.description': 'The rework only changes how the code is built; what the user sees stays the same.',
+        'onboarding.behavior.preserve.label': 'Preserve current behavior',
+        'onboarding.behavior.redesign.description': 'Nothing is implemented until the target screens, flows and contracts are approved.',
+        'onboarding.behavior.redesign.label': 'Redesign the product explicitly',
+        'onboarding.field.change': 'Change to {value}',
+        'onboarding.field.changeDetail': 'The project is saved as {value} and the remaining questions follow it.',
+        'onboarding.field.context': 'This value is saved with the onboarding choices and later work reads it from there instead of guessing. Keep it, write a different one, or leave it undecided; a value left undecided is never saved quietly.',
+        'onboarding.field.defer.description': 'Nothing is saved. Onboarding stops here and you come back to this question once you have decided.',
+        'onboarding.field.defer.label': 'Defer this value explicitly',
+        'onboarding.field.edit.description': 'What you write below is saved instead of the value above.',
+        'onboarding.field.edit.label': 'Edit this value in the field below',
+        'onboarding.field.editTitle': 'Edited value',
+        'onboarding.field.empty': 'not set yet',
+        'onboarding.field.example': 'If the runtime stays Node 22, a later task builds and tests on Node 22 instead of whatever the machine happens to have.',
+        'onboarding.field.idsTitle': 'Project ID JSON array',
+        'onboarding.field.keep.description': 'The value above is saved as it stands.',
+        'onboarding.field.keep.label': 'Keep this exact value',
+        'onboarding.field.value': 'Proposed value',
+        'onboarding.fieldNames.apiContract': 'API contract',
+        'onboarding.fieldNames.architecture': 'Application architecture',
+        'onboarding.fieldNames.authentication': 'Authentication',
+        'onboarding.fieldNames.backendProjectIds': 'Existing backend project links',
+        'onboarding.fieldNames.colorPalette': 'Color palette',
+        'onboarding.fieldNames.designSystem': 'Design system',
+        'onboarding.fieldNames.environments': 'Environments and configuration',
+        'onboarding.fieldNames.figma': 'Figma source',
+        'onboarding.fieldNames.localization': 'Localization languages',
+        'onboarding.fieldNames.migrations': 'Migration strategy',
+        'onboarding.fieldNames.navigation': 'Navigation',
+        'onboarding.fieldNames.platforms': 'Platforms',
+        'onboarding.fieldNames.runtime': 'Runtime and toolchain contract',
+        'onboarding.fieldNames.serviceReadiness': 'Service readiness',
+        'onboarding.fieldNames.stack': 'Application stack',
+        'onboarding.fieldNames.storage': 'Storage and persistence',
+        'onboarding.fieldNames.typography': 'Font families and text styles',
+        'onboarding.git.branchTitle': 'Branch name',
+        'onboarding.git.development.context': 'Every task you start later branches off this one and is compared against it. For a repository that does not exist yet, write the name its first branch will have. The branch is used on the origin remote once that remote is connected.',
+        'onboarding.git.development.example': 'With main here, a later task branches off main and its pull request targets main.',
+        'onboarding.git.development.message': 'Which branch should new task branches start from?',
+        'onboarding.git.development.second.description': 'Nothing is saved and setup stops here; you can continue whenever you want.',
+        'onboarding.git.development.second.label': 'Do not start setup yet',
+        'onboarding.git.production.context': 'It is recorded once so later work knows where a finished change goes. If there is no such branch yet, say so explicitly and you are not asked again.',
+        'onboarding.git.production.example': 'With main as the release branch, where a finished task goes is never asked again.',
+        'onboarding.git.production.message': 'Which branch is this project released from?',
+        'onboarding.git.production.second.description': 'It is recorded as absent and you are not asked again. You can set it later.',
+        'onboarding.git.production.second.label': 'There is no release branch yet',
+        'onboarding.git.set.description': 'That branch is saved for this project.',
+        'onboarding.git.set.label': 'Use the branch named below',
+        'onboarding.git.test.context': 'It is recorded once so later work knows where a finished change is tested. If there is no such branch yet, say so explicitly and you are not asked again.',
+        'onboarding.git.test.example': 'With develop as the test branch, where the tests run is never asked again.',
+        'onboarding.git.test.message': 'Which branch is this project tested on?',
+        'onboarding.git.test.second.description': 'It is recorded as absent and you are not asked again. You can set it later.',
+        'onboarding.git.test.second.label': 'There is no test branch yet',
+        'onboarding.mode.adopt.description': 'The code is read as it stands and written into memory; nothing is redesigned.',
+        'onboarding.mode.adopt.label': 'Learn and preserve the existing architecture',
+        'onboarding.mode.context': 'The answer decides what happens first: the project is set up from scratch, the existing one is read and preserved as it is, or it is read first and then reworked phase by phase. Reading an existing project never changes its code or its architecture.',
+        'onboarding.mode.example': 'Choosing to learn the existing project means the next step reads the code and writes down how it works, without changing a line.',
+        'onboarding.mode.greenfield.description': 'The project starts from the profile you approve next; no existing code is read.',
+        'onboarding.mode.greenfield.label': 'Set up a new or barely-started project',
+        'onboarding.mode.message': 'How should this project enter Engineering Memory?',
+        'onboarding.mode.refresh.description': 'The records already in memory are compared with the current code and the differences come back as proposals.',
+        'onboarding.mode.refresh.label': 'Refresh memory against the current project',
+        'onboarding.mode.rework.description': 'The code is read first, and nothing changes until the rework plan is approved separately.',
+        'onboarding.mode.rework.label': 'Learn first, then plan a phased rework',
+        'onboarding.save.approve.description': 'The choices are saved. Nothing in the code changes.',
+        'onboarding.save.approve.label': 'Save these exact onboarding choices',
+        'onboarding.save.approveGit': 'The choices are saved and Git is prepared in this folder.',
+        'onboarding.save.context': 'Your answers become the onboarding record of this project, and later work reads the stack, the architecture and the remaining choices from there. Memory records and project links are approved separately; nothing is published to memory here.',
+        'onboarding.save.defer.description': 'Nothing is saved. You can go through the questions again later.',
+        'onboarding.save.defer.label': 'Keep the choices pending',
+        'onboarding.save.example': 'After saving, a later task reads the stack and the architecture from here instead of asking you again.',
+        'onboarding.save.git': 'Git is prepared in this folder: existing files stay as they are and none of them is deleted or replaced.',
+        'onboarding.save.message': 'Save the onboarding choices you just went through?',
+        'onboarding.save.route.adopt': 'learn and preserve the existing project',
+        'onboarding.save.route.greenfield': 'set up a new project',
+        'onboarding.save.route.refresh': 'refresh memory against the current project',
+        'onboarding.save.route.rework': 'learn first, then plan a phased rework',
+        'onboarding.save.routeLabel': 'Chosen route',
+        'questionnaire.answer': 'Answer',
+        'questionnaire.everyQuestion': 'To record a decision, answer each question or choose an option that ends the form. You can send a comment without selecting any option.',
+        'questionnaire.example': 'Example',
+        'questionnaire.feedback': 'Write an answer or comment (optional)',
+        'questionnaire.freeAnswer': 'Write another answer (optional)',
+        'questionnaire.freeText': 'You can type a different answer without choosing an option. Free text is not stored and cannot be replayed.',
+        'questionnaire.pending': 'Choose an answer to resolve this decision. Closing or cancelling the form leaves it pending.',
+        'questionnaire.recommended': 'Recommended',
+        'questionnaire.storedText': 'The bounded text field is stored as part of this exact decision and is replayed after restart.',
+        'releaseUnowned.context': 'This checkout was found without an ownership record, so it is protected and handed to no task. Releasing it runs the safety checks again first: a folder with uncommitted work is refused. No file and no branch is ever deleted.',
+        'releaseUnowned.example': 'Once it is released, the next task can start in that folder, and the work committed at {commit} stays on its branch.',
+        'releaseUnowned.message': 'Nobody is recorded as using the {folder} folder. If the agent that worked there has stopped and its delivery is finished, should the clean checkout become reusable?',
+        'releaseUnowned.preserve': 'Keep protected',
+        'releaseUnowned.preserved': 'Nothing changes. The folder stays protected and is given to no task.',
+        'releaseUnowned.release': 'Prior work finished; release after safety checks',
+        'releaseUnowned.released': 'The safety checks run and, if they pass, the folder returns to the pool.',
+        'retireWorktree.context': 'Folders in the old location are no longer part of the pool: they are never reused and do not count toward the limit.',
+        'retireWorktree.contextFolder': 'The branch and its commits stay. Git removes only a clean folder, and the files it ignores go with it.',
+        'retireWorktree.contextMissing': 'Only the record is left, so there is no folder to remove and no file is read or deleted.',
+        'retireWorktree.example': 'After this, {folder} is gone from the worktree list and branch {branch} still holds every commit made on it.',
+        'retireWorktree.exampleMissing': 'After this, {folder} is gone from the worktree list and nothing on disk changes.',
+        'retireWorktree.keep': 'Keep it',
+        'retireWorktree.kept': 'Nothing changes. The folder and its record stay exactly as they are.',
+        'retireWorktree.message': '{folder} is a worktree left in the old location (branch {branch}). Remove the folder?',
+        'retireWorktree.missing': 'The {folder} folder is gone but its worktree record is still here. Remove the record?',
+        'retireWorktree.noBranch': 'none',
+        'retireWorktree.retire': 'Remove the folder',
+        'retireWorktree.retired': 'Git removes the folder and Engineering Memory drops its record. The branch and its commits stay.',
+        'retireWorktree.retiredMissing': 'The stale record is removed. Nothing on disk changes.',
+        'reviewBatch.approved.description': 'Every listed record takes its new text now.',
+        'reviewBatch.approved.label': 'Publish all of them',
+        'reviewBatch.context': 'Publishing replaces the current text of these records for everyone who reads this memory. Earlier revisions stay in the history.',
+        'reviewBatch.defer.description': 'Nothing changes. The proposals stay pending.',
+        'reviewBatch.defer.label': 'Decide later',
+        'reviewBatch.example': 'After publishing, the next session that reads one of these records gets the new text instead of the old one.',
+        'reviewBatch.kinds.api_endpoint': 'api endpoint',
+        'reviewBatch.kinds.architecture_template': 'architecture template',
+        'reviewBatch.kinds.component_mapping': 'component mapping',
+        'reviewBatch.kinds.current_deviation': 'current deviation',
+        'reviewBatch.kinds.data_model': 'data model',
+        'reviewBatch.kinds.engineering_rule': 'engineering rule',
+        'reviewBatch.kinds.figma_mapping': 'figma mapping',
+        'reviewBatch.kinds.figma_reference': 'figma reference',
+        'reviewBatch.kinds.flow_logic': 'flow logic',
+        'reviewBatch.kinds.localization_contract': 'localization contract',
+        'reviewBatch.kinds.module_logic': 'module logic',
+        'reviewBatch.kinds.navigation_contract': 'navigation contract',
+        'reviewBatch.kinds.project_profile': 'project profile',
+        'reviewBatch.kinds.quality_gate': 'quality gate',
+        'reviewBatch.kinds.screen_logic': 'screen logic',
+        'reviewBatch.kinds.service_contract': 'service contract',
+        'reviewBatch.kinds.state_contract': 'state contract',
+        'reviewBatch.newRecord': 'new record',
+        'reviewBatch.oneByOne.description': 'Nothing changes now. Each record is shown in full and decided on its own.',
+        'reviewBatch.oneByOne.label': 'Let me look at them one by one',
+        'reviewBatch.ready': '{count, plural, one {One memory record is ready to be published.} other {# memory records are ready to be published.}}',
+        'reviewBatch.rebase': 'written against an older revision',
+        'reviewBatch.rejected.description': 'Nothing changes. The proposals are marked rejected and have to be written again.',
+        'reviewBatch.rejected.label': 'Reject all of them',
+        'reviewBatch.revision': 'revision {from} to {to}',
+        'reviewBatch.scope.organization': 'organization',
+        'reviewBatch.scope.product': 'product',
+        'reviewBatch.scope.project': 'project',
+        'reviewBatch.untitled': 'untitled {kind}',
+        'reviewBatch.unversioned': 'Written without a source inspection: {titles}. Tasks that read memory by source version will not see them until an inspection retains them.',
+        'reviewBatch.why': 'Why',
+        'reworkPlan.approve.description': 'The work items are created now, exactly as listed. Implementing each phase still starts separately.',
+        'reworkPlan.approve.label': 'Create these work items',
+        'reworkPlan.branch': 'branch',
+        'reworkPlan.context': 'Approving creates one work item per phase, in the dependency order of the plan, and nothing else. No branch is created and no code is changed. Each phase is implemented later as its own task, with its own branch and worktree.',
+        'reworkPlan.defer.description': 'Nothing changes. No work item is created and the plan can be approved later.',
+        'reworkPlan.defer.label': 'Keep the plan for further review',
+        'reworkPlan.example': 'After approval the first phase appears as a work item that can be started, and the phases that depend on it wait until it is done.',
+        'reworkPlan.more': 'and {count} more phases',
+        'reworkPlan.phases': '{count, plural, one {Create the work item for the single phase of this rework plan?} other {Create the work items for the # phases of this rework plan?}}',
+        'ruleDeviation.approve.description': 'The deviation is recorded for this file and the self review continues.',
+        'ruleDeviation.approve.label': 'Keep the code and record the deviation',
+        'ruleDeviation.ask': '{path} breaks a rule of this project. Keep the code as it is?',
+        'ruleDeviation.change.description': 'Nothing is recorded. The self review stops until the code follows the rule and is reviewed again.',
+        'ruleDeviation.change.label': 'Change the code to follow the rule',
+        'ruleDeviation.context': "A rule conflict is yours to decide, not the agent's. Keeping the code records a deviation on this file against that rule: it travels with the self review, stays in the project memory and is what a later task reads before it touches this file.",
+        'ruleDeviation.deviation': 'Deviation',
+        'ruleDeviation.example': 'The next task that opens this file sees the rule and this recorded deviation together, instead of reading the code as if it followed the rule.',
+        'ruleDeviation.rule': 'Rule',
+        'ruleDeviation.unnamed': 'an engineering rule whose name is not recorded',
+        'signIn.completed': 'Authentication completed. You can return to the coding agent.',
+        'signIn.failed': 'Authentication could not be completed.',
+        'signIn.invalid': 'Authentication request is invalid.',
+        'startFallback.approve': 'Continue',
+        'startFallback.approved': 'The new branch is created at {local} now and the task starts.',
+        'startFallback.context': 'The branch you chose cannot be reached, so its exact commit is unavailable. The local copy is whatever was fetched last: commits pushed to the remote since then are not in it. Nothing is created until you answer.',
+        'startFallback.defer': 'Not now',
+        'startFallback.deferred': 'Nothing is created or reserved. The task waits, and it can be started again once the remote answers.',
+        'startFallback.example': 'Continuing creates the new branch at {local}; {remote} can be merged into it once the network is back.',
+        'startFallback.messageHere': 'The remote {remote} could not be fetched. Should the task start from local {local} in this folder?',
+        'startFallback.messageWorktree': 'The remote {remote} could not be fetched. Should the task start from local {local} in a separate worktree?',
+        'statusMeaning.clear.description': 'Review an explicit empty value; other fields remain unchanged.',
+        'statusMeaning.clear.label': 'Clear this field',
+        'statusMeaning.context': 'This step is optional. Feedback or requests for explanation do not save anything; a written definition is reviewed before saving.',
+        'statusMeaning.current': 'Current text',
+        'statusMeaning.defer.description': 'Defer this attempt without changing the stage or existing work.',
+        'statusMeaning.defer.label': 'Do not save now',
+        'statusMeaning.empty': '(empty)',
+        'statusMeaning.fields.entryRule.example': 'Code must be ready and the relevant tests must pass before review.',
+        'statusMeaning.fields.entryRule.inputTitle': 'Your entry condition',
+        'statusMeaning.fields.entryRule.question': 'When should work enter this stage?',
+        'statusMeaning.fields.entryRule.title': 'Stage entry condition',
+        'statusMeaning.fields.meaning.example': 'In Review: development is complete and a teammate needs to review the code.',
+        'statusMeaning.fields.meaning.inputTitle': 'Your stage meaning',
+        'statusMeaning.fields.meaning.question': 'What does work in this stage mean?',
+        'statusMeaning.fields.meaning.title': 'Stage meaning',
+        'statusMeaning.keep.description': 'Leave this field and existing work unchanged.',
+        'statusMeaning.keep.label': 'Keep the current value',
+        'statusMeaning.next.description': 'Show the next part of the text without saving anything yet.',
+        'statusMeaning.next.label': 'Review the next part',
+        'statusMeaning.page': 'Page',
+        'statusMeaning.proposed': 'New text',
+        'statusMeaning.review.context': 'All current and proposed text is shown. Continue through longer text; only the last page can save it. This does not move work or execute an event.',
+        'statusMeaning.review.example': 'Define In Review as “code is ready and awaiting review.” Tasks in that stage remain where they are.',
+        'statusMeaning.review.message': 'Review this field change',
+        'statusMeaning.save.description': 'Save the reviewed field; other fields and existing work remain unchanged.',
+        'statusMeaning.save.label': 'Save this definition',
+        'statusMeaning.write.description': 'Enter your own text and review it before saving.',
+        'statusMeaning.write.label': 'Write a definition',
+        'statusRemap.apply.description': 'Move the listed work to its new stages in one operation, leaving stage definitions and roles unchanged.',
+        'statusRemap.apply.label': 'Move the work',
+        'statusRemap.archived': 'archived',
+        'statusRemap.context': 'Each line shows where all work in one stage moves and how many items it holds. Approval is bound to these counts: if they changed by the time it applies, nothing moves and you are asked again. Stage definitions and roles stay unchanged.',
+        'statusRemap.defer.description': 'Move nothing; this attempt remains deferred.',
+        'statusRemap.defer.label': 'Do not move now',
+        'statusRemap.example': 'The 3 open and 1 archived items in Staging Check move to READY FOR QA; their order, titles and other fields stay the same.',
+        'statusRemap.message': 'Move this work to its new stages?',
+        'statusRemap.next.description': 'Show the rest of the move without moving anything yet.',
+        'statusRemap.next.label': 'Review the next part',
+        'statusRemap.open': 'open',
+        'statusRemap.page': 'Page',
+        'statusRemap.reason': 'Why',
+        'statusRemap.roles.all_prs_merged': 'All PRs merged',
+        'statusRemap.roles.blocked_declared': 'Parked work',
+        'statusRemap.roles.draft_pr_opened': 'Draft PR',
+        'statusRemap.roles.pr_opened': 'PR ready for review',
+        'statusRemap.roles.test_failed': 'Failed test',
+        'statusRemap.roles.work_started': 'Starting development',
+        'statusRemap.rolesStay': 'These roles keep pointing at stages being emptied; change them separately through role setup:',
+        'taskStart.base.fetchDetail': 'Fetch the latest commit.',
+        'taskStart.base.field': 'Branch on origin (only for another branch)',
+        'taskStart.base.local': 'Local: {branch}',
+        'taskStart.base.localDetail': 'Current commit; no fetch.',
+        'taskStart.base.message': 'Which starting branch?',
+        'taskStart.base.other': 'Another branch on origin',
+        'taskStart.base.otherDetail': 'Enter it below.',
+        'taskStart.example': 'A worktree keeps this task in its own folder.',
+        'taskStart.keepContext': 'Continue on the current branch.',
+        'taskStart.location.busy': 'Task {task} is still running in another client in this folder, so the new branch cannot start here. Once it is paused there, this folder can be chosen too.',
+        'taskStart.location.defer.description': 'Create nothing.',
+        'taskStart.location.defer.label': 'Not now',
+        'taskStart.location.dirty': 'This folder has uncommitted changes, so the new branch cannot start here.',
+        'taskStart.location.here.description': 'Switch this folder to the new branch.',
+        'taskStart.location.here.label': 'New branch in this folder',
+        'taskStart.location.holder': 'Starting here moves {task} to a separate worktree; its work is kept.',
+        'taskStart.location.keep.description': 'Continue on {branch}.',
+        'taskStart.location.keep.label': 'Stay on the current branch',
+        'taskStart.location.message': 'Where should we work?',
+        'taskStart.location.worktree.description': 'Leave this folder unchanged.',
+        'taskStart.location.worktree.label': 'Separate worktree',
+        'taskStart.message': 'Start task',
+        'taskStart.newBranch': 'New branch: {name}',
+        'taskStart.stay': 'Nothing new is created. The work continues on {source} in this folder, so every commit lands on that branch.',
+        'uiWaiver.ask': '{task}: skip the UI check (widget, golden or screenshot test) for this task?',
+        'uiWaiver.context': 'The UI check is what proves the screens this task changed still render. Skipping it means nothing in this task opens them, and the skip is stored in the task audit trail with the reason above.',
+        'uiWaiver.example': 'A layout this change broke would pass verification and first show up when someone opens the app.',
+        'uiWaiver.files': 'Changed files that draw the interface: {files}',
+        'uiWaiver.reason': 'The reason you gave: {reason}',
+        'uiWaiver.require.description': 'Nothing is skipped. The task stays unverified until a widget, golden or screenshot test covers these files.',
+        'uiWaiver.require.label': 'Keep the UI check required',
+        'uiWaiver.waive.description': 'The task verifies without a widget, golden or screenshot test of these files, and the skip is recorded.',
+        'uiWaiver.waive.label': 'Skip the UI check',
+        'whatsNew.badge': '{count, plural, one {# improvement} other {# improvements}} · Package {version}',
+        'whatsNew.build': 'Build {number}',
+        'whatsNew.example': 'In everyday use',
+        'whatsNew.footer': 'Dates indicate the first announcement in this catalogue. This local report reflects availability when it was created; you can continue your task as usual.',
+        'whatsNew.intro': 'Improvements available with your installed package, with examples of how they help in your daily work.',
+        'whatsNew.title': "What's new in EM?",
+        'workflow.approve.description': 'Save the five displayed choices together without moving existing work.',
+        'workflow.approve.label': 'Save these settings',
+        'workflow.defer.description': 'Apply nothing; this attempt remains deferred.',
+        'workflow.defer.label': 'Do not save now',
+        'workflow.modes.automatic': 'Automatic',
+        'workflow.modes.confirm': 'Ask for approval',
+        'workflow.modes.ignore': 'Ignore this event',
+        'workflow.next.description': 'Show the next stages for this same decision.',
+        'workflow.next.label': 'Next stages',
+        'workflow.page': 'Page',
+        'workflow.previous.description': 'Return to the previous stages for this same decision.',
+        'workflow.previous.label': 'Previous stages',
+        'workflow.review.context': 'The five stages and behaviors appear below. Draft PR and new-work initial settings stay unchanged. This saves configuration only; no event is executed.',
+        'workflow.review.example': 'Choosing On Hold for parked work stores that preference for the project; earlier tasks remain in place.',
+        'workflow.review.message': 'Save these workflow settings together?',
+        'workflow.roles.all_prs_merged.context': 'This configures the step after every PR belonging to the work has merged.',
+        'workflow.roles.all_prs_merged.example': 'Both the web change and its backend change have been merged.',
+        'workflow.roles.all_prs_merged.message': 'Which stage should represent all PRs being merged?',
+        'workflow.roles.all_prs_merged.title': 'All PRs merged',
+        'workflow.roles.blocked_declared.context': 'Choose the active parked stage; existing work stays where it is.',
+        'workflow.roles.blocked_declared.example': 'You put a task on hold while waiting for an external service.',
+        'workflow.roles.blocked_declared.message': 'Which stage should hold parked work?',
+        'workflow.roles.blocked_declared.title': 'Parked work',
+        'workflow.roles.pr_opened.context': 'Draft PR behavior stays unchanged; this configures the ready-for-review step.',
+        'workflow.roles.pr_opened.example': 'Use this stage when your completed change is ready for a teammate to review.',
+        'workflow.roles.pr_opened.message': 'Which stage should represent a PR ready for review?',
+        'workflow.roles.pr_opened.title': 'PR ready for review',
+        'workflow.roles.test_failed.context': 'Choose the stage for work that needs changes after a failed test.',
+        'workflow.roles.test_failed.example': 'A payment test found a problem and the work needs a correction.',
+        'workflow.roles.test_failed.message': 'Which stage should represent a failed test?',
+        'workflow.roles.test_failed.title': 'Failed test',
+        'workflow.roles.work_started.context': 'This is separate from the stage where new work is created.',
+        'workflow.roles.work_started.example': 'Choose the stage used when you begin fixing a payment bug.',
+        'workflow.roles.work_started.message': 'Which stage should represent starting development?',
+        'workflow.roles.work_started.title': 'Development',
+    },
+    tr: {
+        'cancelDelivery.context': 'Teslimi iptal edilen bir klasör, sen ne olacağını söyleyene kadar bu göreve ayrılmış kalır ve ayrılmış klasör worktree sınırına sayılmaya devam eder. Dal ve üzerindeki commit’ler her hâlükârda durur.',
+        'cancelDelivery.example': 'Klasör boşaltılırsa sıradaki görev burada başlayabilir; kalsın dersen bu göreve ayrılmış hâlde durur.',
+        'cancelDelivery.keep': 'Klasör olduğu gibi kalsın',
+        'cancelDelivery.kept': 'Hiçbir şey değişmez. Klasör bu göreve ayrılmış hâlde kalır.',
+        'cancelDelivery.message': '{task} teslim edilmeyecek. Bu klasör ne olsun?',
+        'cancelDelivery.release': 'Klasörü boşalt; branch kalsın',
+        'cancelDelivery.released': 'Klasör havuza döner. Dosyalarına dokunulmaz, dal kalır.',
+        'cancelDelivery.save': 'Değişiklikleri kaydedip klasörü boşalt',
+        'cancelDelivery.saved': 'Kaydedilmemiş değişiklikler önce bir Git ref’ine yazılır, sonra klasör boşaltılır. Değişiklikler o ref’ten geri alınabilir.',
+        'cancelDelivery.uncommittedManaged': 'Klasörde kaydedilmemiş değişiklikler var; kaydedilirse bir Git ref’ine yazılır ve oradan geri alınabilir.',
+        'cancelDelivery.uncommittedOwn': 'Klasörde kaydedilmemiş değişiklikler var; burası senin kendi klasörün olduğu için boşaltılsa da dosyalara dokunulmaz.',
+        'decisionMode.approveForMe.description': 'Sıradan kararları ben veririm; çok kritik olanları sana sorarım.',
+        'decisionMode.approveForMe.label': 'Benim için onayla',
+        'decisionMode.ask.description': 'Karar gereken her durumda sana sorarım.',
+        'decisionMode.ask.label': 'Onay iste',
+        'decisionMode.autonomous.description': 'Seçenekleri senin hedeflerine göre değerlendirip kararları gerekçesiyle veririm.',
+        'decisionMode.autonomous.label': 'Otonom',
+        'decisionMode.context': 'Seçim bu task için geçerli; istediğinde değiştirebilirsin.',
+        'decisionMode.example': 'Örneğin canlıya alma kararını ajana bırakabilir veya kendin onaylayabilirsin.',
+        'decisionMode.start': 'Bu taskta nasıl ilerleyelim?',
+        'decisionMode.switch': 'Hangi moda geçelim?',
+        'delivery.baseContext': 'Hedef dalı açıkça belirt. Depodaki varsayılan dalı kendiliğimizden seçmeyiz.',
+        'delivery.baseMessage': 'PR/MR hangi dala açılsın?',
+        'delivery.baseTitle': 'Hedef dal',
+        'delivery.baseWrite.description': 'Yazdığın dalı hedef al; birleştirme ayrı bir karardır.',
+        'delivery.baseWrite.label': 'Bu dala aç',
+        'delivery.commit.description': 'Değişiklikleri bu yerel dalda kaydet.',
+        'delivery.commit.label': 'Yalnızca commit',
+        'delivery.commit_push.description': 'Bu dalı belirtilen uzak depoya gönder.',
+        'delivery.commit_push.label': 'Commit ve push',
+        'delivery.commit_push_draft_pr.description': 'Dalı gönder; henüz incelemeye hazır olmayan bir taslak aç.',
+        'delivery.commit_push_draft_pr.label': 'Commit, push ve taslak PR/MR',
+        'delivery.commit_push_pr.description': 'Dalı gönder ve incelemeye hazır bir istek aç.',
+        'delivery.commit_push_pr.label': 'Commit, push ve PR/MR',
+        'delivery.context': 'Görev doğrulandı ve kapandı. Bu seçim kodun nereye gönderileceğini belirler; hafıza değişikliklerini yayımlama onayı bunun yerine geçmez.',
+        'delivery.defer.description': 'Görev kapalı kalır; dosyalar korunur, Git teslimi yapılmaz.',
+        'delivery.defer.label': 'Şimdilik beklet',
+        'delivery.destination': 'Dal / uzak depo',
+        'delivery.example': 'Commit yerel dalda kalır. PR/MR seçersen değişiklikler uzak dala gönderilir ve ekip incelemesine açılır.',
+        'delivery.message': 'Değişiklikleri nasıl teslim edelim?',
+        'forgetWorktree.context': 'Okunamayan bir çalışma kopyası hiçbir işe yaramadığı hâlde worktree sınırına sayılmaya devam eder; takipten çıkarılırsa o yer boşalır. Klasördeki hiçbir dosyaya dokunulmaz, hiçbiri silinmez; dal da kalır.',
+        'forgetWorktree.example': 'Bundan sonra {task} worktree listesinde görünmez, {folder} klasörü ise diskte olduğu gibi kalır.',
+        'forgetWorktree.forget': 'Takip etmeyi bırak; dosyalara dokunma',
+        'forgetWorktree.forgotten': 'Kayıt silinir ve sınırdaki yer boşalır. Klasör, içindeki dosyalar ve dal olduğu gibi kalır.',
+        'forgetWorktree.keep': 'Takip etmeye devam et',
+        'forgetWorktree.kept': 'Hiçbir şey değişmez. Kayıt durur ve sınıra sayılmaya devam eder.',
+        'forgetWorktree.message': '{task} görevinin {folder} klasörü artık bir Git çalışma kopyası olarak okunamıyor. Engineering Memory bu klasörü takip etmeyi bıraksın mı?',
+        'forgetWorktree.pendingDelivery': 'Bu görev teslimi sonuçlanmadan kapandı; teslim edilmemiş iş varsa yalnızca bu klasörde duruyor.',
+        'gitPreferences.ask.development': 'Geliştirme dalı {source} olarak kaydedilsin mi?',
+        'gitPreferences.ask.production': 'Canlı dalı {source} olarak kaydedilsin mi?',
+        'gitPreferences.ask.test': 'Test dalı {source} olarak kaydedilsin mi?',
+        'gitPreferences.askNone.development': 'Bu projede geliştirme dalı olmadığı kaydedilsin mi?',
+        'gitPreferences.askNone.production': 'Bu projede canlı dalı olmadığı kaydedilsin mi?',
+        'gitPreferences.askNone.test': 'Bu projede test dalı olmadığı kaydedilsin mi?',
+        'gitPreferences.context': 'Bu dallar projenin tamamı için geçerli: burada görev başlatan herkese, görevin başlayacağı dal olarak bunlar önerilir. Yalnızca proje ya da organizasyon yöneticisi değiştirebilir. Hiçbir dal oluşturulmaz, taşınmaz veya silinmez; yalnızca tercih kaydedilir.',
+        'gitPreferences.example': 'Geliştirme dalı origin/develop olarak kaydedilirse, bir sonraki görevin başlangıç formunda ilk seçenek origin/develop olur.',
+        'gitPreferences.leave': 'Şimdilik değiştirme',
+        'gitPreferences.message': 'Projenin ortak dal tercihleri kaydedilsin mi? Sen cevaplayana kadar hiçbir şey kaydedilmez.',
+        'gitPreferences.save': 'Bu tercihi kaydet',
+        'gitPreferences.saved': 'Bu dal şimdi proje varsayılanı olarak kaydedilir; ekipteki herkes onu görür.',
+        'gitPreferences.unchanged': 'Hiçbir şey değişmez. Bu rol olduğu gibi kalır, sonra yeniden sorulabilir.',
+        'inspection.defer': 'Şimdilik başlatma',
+        'inspection.deferDetail': 'İnceleme başlamaz, hiçbir şey yazılmaz. Cevabın kaydedilir; bu kaynağı sonra incelemek yeni bir istek olur.',
+        'inspection.example': 'İnceleme bitince her ekran, servis ve akış için birer hafıza kaydı önerilir; hangilerinin yayınlanacağına sen karar verirsin.',
+        'inspection.localChanges': 'Uygulama kodu değiştirilmeyecek. Commit edilmemiş değişiklikler ortak hafızaya alınmayacak.',
+        'inspection.modes.adopt': 'Mevcut projeyi mimarisiyle birlikte öğrenmeye başlayalım mı?',
+        'inspection.modes.refresh': 'Projenin hafızasını güncel kodla karşılaştırıp incelemeyi başlatalım mı?',
+        'inspection.modes.rework': 'Rework planından önce mevcut projeyi incelemeye başlayalım mı?',
+        'inspection.review': 'Bu onay incelemeyi başlatır. Kalıcı hafıza değişiklikleri ayrıca onayına sunulacak.',
+        'inspection.rework.preserve': 'Rework hedefi: mevcut davranışı korumak.',
+        'inspection.rework.redesign': 'Rework hedefi: ürünü yeniden tasarlamak. Uygulama öncesinde hedef ayrıca onaylanacak.',
+        'inspection.scope': 'Mimari, state yönetimi, servisler, network katmanı, veri modelleri, ekranlar ve akışlar incelenecek.',
+        'inspection.source': 'Kaynak',
+        'inspection.start': 'İncelemeyi başlat',
+        'inspection.startDetail': 'İnceleme şimdi başlar. Kod değişmez; çıkan kayıtlar sonunda tek tek onayına gelir.',
+        'inspection.why.adopt': 'Proje ilk kez hafızaya alınıyor. İnceleme, bu kaynaktaki kodu okuyup projenin nasıl çalıştığını çıkarır.',
+        'inspection.why.refresh': 'İnceleme, hafızadaki kayıtları bu kaynaktaki kodla karşılaştırır ve neyin değiştiğini çıkarır.',
+        'inspection.why.rework': 'Yeniden yazım planının yazılabilmesi için önce projenin bugünkü hâli okunmalı.',
+        'move.after': 'Eski depo projenin geçmişinde saklanır. Hâlâ eski depoda çalışan ekip arkadaşları açık görevlerini bitirebilir, yeni görevi yeni depodan açar. Proje ileride yeniden taşınabilir.',
+        'move.approve.description': 'Proje bundan sonra bu depoyu gösterir; burada hemen çalışmaya başlayabilirsin.',
+        'move.approve.label': 'Projeyi bu depoya taşı',
+        'move.ask': '"{name}" projesini bu depoya taşıyalım mı?',
+        'move.decline.description': 'Hiçbir şey değişmez. Proje mevcut deposunda kalır ve bu klasörde iş başlatılamaz.',
+        'move.decline.label': 'Taşıma',
+        'move.example': 'Taşıdıktan sonra bu klasörde açtığın görev aynı projeye ait olur ve aynı hafızayı okur.',
+        'move.from': 'Projenin şu anki deposu',
+        'move.keeps': 'Proje olduğu gibi devam eder: {tasks} görev, {records} hafıza kaydı ve {items} iş kalemi projede kalır, hiçbir şey silinmez ve yeniden öğrenilmez.',
+        'move.to': 'Bu klasörün deposu',
+        'move.unknown': 'adresi kayıtlı değil',
+        'move.why': 'Projenin kodu başka bir depoya taşınmış. Bu klasör projenin evi sayılmadığı için burada yeni iş başlatılamıyor.',
+        'onboarding.behavior.context': 'Bu seçim hem incelemenin hem de planın hedefini belirler. Korumak, kullanıcının gördüğü ekranlar ve akışlar aynı kalırken altındaki kodun değişmesi demek. Yeniden tasarlamak ürünün kendisinin değişmesi demek; o zaman hedef ekranlar, akışlar ve sözleşmeler uygulamaya geçilmeden önce ayrıca onaylanır.',
+        'onboarding.behavior.example': 'Davranışı korursan, bugün seri numarası soran ekran yeniden yazımdan sonra da seri numarası sorar.',
+        'onboarding.behavior.message': 'Yeniden yazım, ürünün bugünkü davranışını koruyacak mı yoksa ürünü yeniden mi tasarlayacak?',
+        'onboarding.behavior.preserve.description': 'Yeniden yazım yalnızca kodun yapısını değiştirir; kullanıcının gördüğü aynı kalır.',
+        'onboarding.behavior.preserve.label': 'Bugünkü davranışı koru',
+        'onboarding.behavior.redesign.description': 'Hedef ekranlar, akışlar ve sözleşmeler onaylanmadan hiçbir şey uygulanmaz.',
+        'onboarding.behavior.redesign.label': 'Ürünü açıkça yeniden tasarla',
+        'onboarding.field.change': '{value} olarak değiştir',
+        'onboarding.field.changeDetail': 'Proje {value} olarak kaydedilir ve kalan sorular buna göre gelir.',
+        'onboarding.field.context': 'Bu değer kurulum seçimleriyle birlikte kaydedilir; sonraki görevler tahmin etmek yerine buradan okur. Olduğu gibi bırakabilir, farklı bir değer yazabilir ya da şimdilik boş bırakabilirsin; boş bıraktığın bir değer sessizce kaydedilmez.',
+        'onboarding.field.defer.description': 'Hiçbir şey kaydedilmez. Kurulum burada durur; karar verdiğinde bu soruya dönersin.',
+        'onboarding.field.defer.label': 'Bu değeri şimdilik boş bırak',
+        'onboarding.field.edit.description': 'Aşağıya yazdığın metin, yukarıdaki değerin yerine kaydedilir.',
+        'onboarding.field.edit.label': 'Aşağıdaki alana farklı bir değer yaz',
+        'onboarding.field.editTitle': 'Yeni değer',
+        'onboarding.field.empty': 'henüz belirlenmedi',
+        'onboarding.field.example': 'Çalışma ortamı Node 22 olarak kalırsa sonraki görev makinede ne varsa ona göre değil, Node 22 üzerinde derleyip test eder.',
+        'onboarding.field.idsTitle': 'Proje ID listesi (JSON dizisi)',
+        'onboarding.field.keep.description': 'Yukarıdaki değer aynen kaydedilir.',
+        'onboarding.field.keep.label': 'Bu değeri olduğu gibi kaydet',
+        'onboarding.field.value': 'Önerilen değer',
+        'onboarding.fieldNames.apiContract': 'API sözleşmesi',
+        'onboarding.fieldNames.architecture': 'Uygulama mimarisi',
+        'onboarding.fieldNames.authentication': 'Kimlik doğrulama',
+        'onboarding.fieldNames.backendProjectIds': 'Bağlı backend projeleri',
+        'onboarding.fieldNames.colorPalette': 'Renk paleti',
+        'onboarding.fieldNames.designSystem': 'Tasarım sistemi',
+        'onboarding.fieldNames.environments': 'Ortamlar ve konfigürasyon',
+        'onboarding.fieldNames.figma': 'Figma kaynağı',
+        'onboarding.fieldNames.localization': 'Desteklenen diller',
+        'onboarding.fieldNames.migrations': 'Migration stratejisi',
+        'onboarding.fieldNames.navigation': 'Gezinme',
+        'onboarding.fieldNames.platforms': 'Platformlar',
+        'onboarding.fieldNames.runtime': 'Çalışma ortamı ve araç sürümleri',
+        'onboarding.fieldNames.serviceReadiness': 'Servislerin hazır olup olmadığı',
+        'onboarding.fieldNames.stack': 'Uygulama teknolojisi',
+        'onboarding.fieldNames.storage': 'Veri saklama',
+        'onboarding.fieldNames.typography': 'Yazı tipleri ve metin stilleri',
+        'onboarding.git.branchTitle': 'Dal adı',
+        'onboarding.git.development.context': 'Bundan sonra açtığın her görev bu daldan dallanır ve bu dalla karşılaştırılır. Henüz var olmayan bir depo için ilk dalın alacağı ismi yaz. Dal, depo origin adresine bağlandıktan sonra orada kullanılır.',
+        'onboarding.git.development.example': 'Buraya main yazarsan sonraki görev main üzerinden dallanır ve pull request main dalına açılır.',
+        'onboarding.git.development.message': 'Yeni görev dalları hangi daldan başlasın?',
+        'onboarding.git.development.second.description': 'Hiçbir şey kaydedilmez, kurulum burada durur; istediğinde devam edebilirsin.',
+        'onboarding.git.development.second.label': 'Şimdilik kuruluma başlama',
+        'onboarding.git.production.context': 'Bir kez kaydedilir; sonraki işler biten bir değişikliğin nereye gideceğini buradan bilir. Böyle bir dal henüz yoksa bunu açıkça söyle, bir daha sorulmaz.',
+        'onboarding.git.production.example': 'Canlı dal main ise, biten bir görevin nereye gideceği sana tekrar sorulmaz.',
+        'onboarding.git.production.message': 'Bu projenin canlı sürümü hangi daldan çıkıyor?',
+        'onboarding.git.production.second.description': 'Yok olarak kaydedilir ve bir daha sorulmaz. İleride belirleyebilirsin.',
+        'onboarding.git.production.second.label': 'Henüz canlı dal yok',
+        'onboarding.git.set.description': 'Yazdığın dal bu proje için kaydedilir.',
+        'onboarding.git.set.label': 'Aşağıya yazdığım dalı kullan',
+        'onboarding.git.test.context': 'Bir kez kaydedilir; sonraki işler biten bir değişikliğin nerede test edileceğini buradan bilir. Böyle bir dal henüz yoksa bunu açıkça söyle, bir daha sorulmaz.',
+        'onboarding.git.test.example': 'Test dalı develop ise, testlerin hangi dalda koştuğu sana tekrar sorulmaz.',
+        'onboarding.git.test.message': 'Bu proje hangi dalda test ediliyor?',
+        'onboarding.git.test.second.description': 'Yok olarak kaydedilir ve bir daha sorulmaz. İleride belirleyebilirsin.',
+        'onboarding.git.test.second.label': 'Henüz test dalı yok',
+        'onboarding.mode.adopt.description': 'Kod olduğu gibi okunup hafızaya yazılır; hiçbir şey yeniden tasarlanmaz.',
+        'onboarding.mode.adopt.label': 'Mevcut mimariyi öğren ve koru',
+        'onboarding.mode.context': 'Cevabın ilk adımı belirler: proje sıfırdan mı kurulacak, mevcut proje olduğu gibi okunup korunacak mı, yoksa önce okunup sonra aşama aşama mı yeniden yazılacak. Mevcut bir projeyi okumak ne kodu ne de mimarisini değiştirir.',
+        'onboarding.mode.example': 'Mevcut projeyi öğrenmeyi seçersen bir sonraki adım kodu okuyup nasıl çalıştığını kayda geçirir; tek satır bile değişmez.',
+        'onboarding.mode.greenfield.description': 'Proje birazdan onaylayacağın profille başlar; mevcut kod okunmaz.',
+        'onboarding.mode.greenfield.label': 'Yeni ya da yeni başlamış bir proje kur',
+        'onboarding.mode.message': 'Bu proje Engineering Memory hafızasına nasıl alınsın?',
+        'onboarding.mode.refresh.description': 'Hafızadaki kayıtlar güncel kodla karşılaştırılır, farklar öneri olarak önüne gelir.',
+        'onboarding.mode.refresh.label': 'Hafızayı güncel projeyle tazele',
+        'onboarding.mode.rework.description': 'Önce kod okunur; yeniden yazım planı ayrıca onaylanmadan hiçbir şey değişmez.',
+        'onboarding.mode.rework.label': 'Önce öğren, sonra aşama aşama yeniden yazmayı planla',
+        'onboarding.save.approve.description': 'Seçimler kaydedilir. Kodda hiçbir şey değişmez.',
+        'onboarding.save.approve.label': 'Bu seçimleri kaydet',
+        'onboarding.save.approveGit': 'Seçimler kaydedilir ve bu klasörde Git hazırlanır.',
+        'onboarding.save.context': 'Verdiğin cevaplar bu projenin kurulum kaydı olur; sonraki işler teknolojiyi, mimariyi ve kalan seçimleri oradan okur. Hafıza kayıtları ve proje bağlantıları ayrıca onaylanır, burada hafızaya hiçbir şey yayınlanmaz.',
+        'onboarding.save.defer.description': 'Hiçbir şey kaydedilmez. Soruları sonra yeniden geçebilirsin.',
+        'onboarding.save.defer.label': 'Seçimleri beklemede bırak',
+        'onboarding.save.example': 'Kaydettikten sonra sonraki görev teknolojiyi ve mimariyi sana tekrar sormadan buradan okur.',
+        'onboarding.save.git': 'Bu klasörde Git hazırlanır; mevcut dosyalar olduğu gibi kalır, hiçbiri silinmez veya değiştirilmez.',
+        'onboarding.save.message': 'Bu kurulum seçimlerini kaydedelim mi?',
+        'onboarding.save.route.adopt': 'mevcut projeyi öğren ve koru',
+        'onboarding.save.route.greenfield': 'yeni bir proje kur',
+        'onboarding.save.route.refresh': 'hafızayı güncel projeyle tazele',
+        'onboarding.save.route.rework': 'önce öğren, sonra aşama aşama yeniden yazmayı planla',
+        'onboarding.save.routeLabel': 'Seçilen yol',
+        'questionnaire.answer': 'Yanıt',
+        'questionnaire.everyQuestion': 'Karar vermek için soruları cevapla veya formu bitiren bir seçenek seç. Hiçbir seçenek seçmeden yorum da gönderebilirsin.',
+        'questionnaire.example': 'Örnek',
+        'questionnaire.feedback': 'Yanıtını veya yorumunu yaz (isteğe bağlı)',
+        'questionnaire.freeAnswer': 'Farklı yanıtını yaz (isteğe bağlı)',
+        'questionnaire.freeText': 'Bir seçenek seçmeden farklı yanıtını yazabilirsin. Serbest yanıt saklanmaz ve daha sonra geri getirilemez.',
+        'questionnaire.pending': 'Kararını kaydetmek için bir seçenek seç. Formu kapatmak veya iptal etmek onay sayılmaz; soru beklemede kalır.',
+        'questionnaire.recommended': 'Önerilen',
+        'questionnaire.storedText': 'Bu metin alanındaki yanıt kararınla birlikte saklanır; yeniden başlattığında korunur.',
+        'releaseUnowned.context': 'Bu çalışma kopyası sahiplik kaydı olmadan bulundu; bu yüzden korunuyor ve hiçbir göreve verilmiyor. Serbest bırakmadan önce güvenlik kontrolleri yeniden çalışır: kaydedilmemiş iş varsa işlem yapılmaz. Hiçbir dosya ve hiçbir dal silinmez.',
+        'releaseUnowned.example': 'Serbest bırakılırsa sıradaki görev bu klasörde başlayabilir; {commit} commit’ine kaydedilmiş iş dalında durmaya devam eder.',
+        'releaseUnowned.message': '{folder} klasörünü kimin kullandığı kayıtlı değil. Burada çalışan ajan durduysa ve teslimi bittiyse, temiz klasör yeniden kullanılabilir hâle gelsin mi?',
+        'releaseUnowned.preserve': 'Korumaya devam et',
+        'releaseUnowned.preserved': 'Hiçbir şey değişmez. Klasör korunur ve hiçbir göreve verilmez.',
+        'releaseUnowned.release': 'Önceki iş bitti; güvenlik kontrollerinden sonra kullanılabilir yap',
+        'releaseUnowned.released': 'Güvenlik kontrolleri çalışır; geçerse klasör havuza döner.',
+        'retireWorktree.context': 'Eski konumdaki klasörler artık havuzun parçası değil: yeniden kullanılmıyorlar ve sınıra da sayılmıyorlar.',
+        'retireWorktree.contextFolder': 'Dal ve üzerindeki commit’ler kalır. Git yalnızca temiz bir klasörü kaldırır; kaldırırken .gitignore kapsamındaki dosyalar da gider.',
+        'retireWorktree.contextMissing': 'Geriye yalnızca kayıt kaldı; kaldırılacak bir klasör yok, hiçbir dosya okunmaz veya silinmez.',
+        'retireWorktree.example': 'Bundan sonra {folder} worktree listesinde görünmez; {branch} dalındaki commit’ler ise yerinde durur.',
+        'retireWorktree.exampleMissing': 'Bundan sonra {folder} worktree listesinde görünmez; diskte hiçbir şey değişmez.',
+        'retireWorktree.keep': 'Kalsın',
+        'retireWorktree.kept': 'Hiçbir şey değişmez. Klasör de kaydı da olduğu gibi kalır.',
+        'retireWorktree.message': '{folder}, eski konumda kalmış bir worktree (dal {branch}). Klasör kaldırılsın mı?',
+        'retireWorktree.missing': '{folder} klasörü artık yok ama worktree kaydı duruyor. Kayıt silinsin mi?',
+        'retireWorktree.noBranch': 'yok',
+        'retireWorktree.retire': 'Klasörü kaldır',
+        'retireWorktree.retired': 'Git klasörü kaldırır, Engineering Memory de kaydını siler. Dal ve commit’ler kalır.',
+        'retireWorktree.retiredMissing': 'Boşta kalan kayıt silinir. Diskte hiçbir şey değişmez.',
+        'reviewBatch.approved.description': 'Listedeki her kayıt şimdi yeni metnine geçer.',
+        'reviewBatch.approved.label': 'Hepsini yayınla',
+        'reviewBatch.context': 'Yayınlarsan bu kayıtların mevcut metni, bu hafızayı okuyan herkes için değişir. Eski sürümler geçmişte kalır.',
+        'reviewBatch.defer.description': 'Hiçbir şey değişmez. Öneriler beklemede kalır.',
+        'reviewBatch.defer.label': 'Şimdilik karar verme',
+        'reviewBatch.example': 'Yayınladıktan sonra bu kayıtlardan birini okuyan bir sonraki oturum eski metni değil yenisini görür.',
+        'reviewBatch.kinds.api_endpoint': 'API endpoint kaydı',
+        'reviewBatch.kinds.architecture_template': 'mimari şablonu',
+        'reviewBatch.kinds.component_mapping': 'bileşen eşlemesi',
+        'reviewBatch.kinds.current_deviation': 'kayıtlı sapma',
+        'reviewBatch.kinds.data_model': 'veri modeli',
+        'reviewBatch.kinds.engineering_rule': 'mühendislik kuralı',
+        'reviewBatch.kinds.figma_mapping': 'Figma eşlemesi',
+        'reviewBatch.kinds.figma_reference': 'Figma referansı',
+        'reviewBatch.kinds.flow_logic': 'akış mantığı',
+        'reviewBatch.kinds.localization_contract': 'yerelleştirme sözleşmesi',
+        'reviewBatch.kinds.module_logic': 'modül mantığı',
+        'reviewBatch.kinds.navigation_contract': 'gezinme sözleşmesi',
+        'reviewBatch.kinds.project_profile': 'proje profili',
+        'reviewBatch.kinds.quality_gate': 'kalite kapısı',
+        'reviewBatch.kinds.screen_logic': 'ekran mantığı',
+        'reviewBatch.kinds.service_contract': 'servis sözleşmesi',
+        'reviewBatch.kinds.state_contract': 'durum yönetimi sözleşmesi',
+        'reviewBatch.newRecord': 'yeni kayıt',
+        'reviewBatch.oneByOne.description': 'Şimdi hiçbir şey değişmez. Her kayıt tam metniyle gösterilir ve ayrı ayrı karara bağlanır.',
+        'reviewBatch.oneByOne.label': 'Tek tek bakayım',
+        'reviewBatch.ready': '{count, plural, one {Bir hafıza kaydı yayına hazır.} other {# hafıza kaydı yayına hazır.}}',
+        'reviewBatch.rebase': 'eski bir sürüme göre yazılmış',
+        'reviewBatch.rejected.description': 'Hiçbir şey değişmez. Öneriler reddedilir ve yeniden yazılmaları gerekir.',
+        'reviewBatch.rejected.label': 'Hepsini reddet',
+        'reviewBatch.revision': 'sürüm {from} → {to}',
+        'reviewBatch.scope.organization': 'organizasyon',
+        'reviewBatch.scope.product': 'ürün',
+        'reviewBatch.scope.project': 'proje',
+        'reviewBatch.untitled': 'başlıksız {kind}',
+        'reviewBatch.unversioned': 'Kaynak incelemesi yapılmadan yazılanlar: {titles}. Hafızayı kaynak sürümüne göre okuyan görevler, bir inceleme bunları saklayana kadar görmez.',
+        'reviewBatch.why': 'Nedeni',
+        'reworkPlan.approve.description': 'İş kalemleri listelendiği gibi şimdi oluşturulur. Aşamaların kodlanması yine ayrı ayrı başlar.',
+        'reworkPlan.approve.label': 'Bu iş kalemlerini oluştur',
+        'reworkPlan.branch': 'dal',
+        'reworkPlan.context': 'Onaylarsan plandaki her aşama için bağımlılık sırasına göre birer iş kalemi oluşturulur; başka hiçbir şey olmaz. Dal açılmaz, koda dokunulmaz. Her aşama daha sonra kendi görevi, kendi dalı ve kendi worktree ile ayrı ayrı yapılır.',
+        'reworkPlan.defer.description': 'Hiçbir şey değişmez. İş kalemi oluşturulmaz, planı sonra onaylayabilirsin.',
+        'reworkPlan.defer.label': 'Plan beklemede kalsın',
+        'reworkPlan.example': 'Onaydan sonra ilk aşama başlatılabilir bir iş kalemi olarak görünür; ona bağlı aşamalar o bitene kadar bekler.',
+        'reworkPlan.more': 've {count} aşama daha',
+        'reworkPlan.phases': '{count, plural, one {Bu yeniden yazım planındaki tek aşama için iş kalemi oluşturalım mı?} other {Bu yeniden yazım planındaki # aşama için iş kalemleri oluşturalım mı?}}',
+        'ruleDeviation.approve.description': 'Sapma bu dosya için kaydedilir ve inceleme devam eder.',
+        'ruleDeviation.approve.label': 'Kodu olduğu gibi bırak ve sapmayı kaydet',
+        'ruleDeviation.ask': '{path} dosyası bu projenin bir kuralına uymuyor. Kod olduğu gibi kalsın mı?',
+        'ruleDeviation.change.description': 'Hiçbir şey kaydedilmez. Kod kurala uyup yeniden incelenene kadar inceleme durur.',
+        'ruleDeviation.change.label': 'Kodu kurala uyacak şekilde değiştir',
+        'ruleDeviation.context': 'Kural çatışmasında kararı kodu yazan değil sen verirsin. Kodu olduğu gibi bırakırsan bu dosya için o kurala ait bir sapma kaydedilir: sapma incelemeyle birlikte gider, proje hafızasında kalır ve bu dosyaya sonradan dokunan görev önce onu okur.',
+        'ruleDeviation.deviation': 'Sapma',
+        'ruleDeviation.example': 'Bu dosyayı sonra açan görev, kuralı ve kaydedilen bu sapmayı birlikte görür; kodu kurala uyuyormuş gibi okumaz.',
+        'ruleDeviation.rule': 'Kural',
+        'ruleDeviation.unnamed': 'adı kayıtlı olmayan bir mühendislik kuralı',
+        'signIn.completed': 'Giriş tamamlandı. Kod ajanına dönebilirsin.',
+        'signIn.failed': 'Giriş tamamlanamadı.',
+        'signIn.invalid': 'Giriş isteği geçersiz.',
+        'startFallback.approve': 'Devam et',
+        'startFallback.approved': 'Yeni dal şimdi {local} üzerinden açılır ve görev başlar.',
+        'startFallback.context': 'Seçtiğin dala ulaşılamadığı için tam commit’i alınamıyor. Yerel kopya, en son çekilen hâli gösterir: o günden sonra uzak dala giden commit’ler burada yok. Sen cevaplayana kadar hiçbir şey oluşturulmaz.',
+        'startFallback.defer': 'Şimdilik başlatma',
+        'startFallback.deferred': 'Hiçbir şey oluşturulmaz, hiçbir yer ayrılmaz. Görev bekler; uzak dala ulaşıldığında yeniden başlatılabilir.',
+        'startFallback.example': 'Devam edersen yeni dal {local} üzerinden açılır; ağ düzeldiğinde {remote} dalını bu dala birleştirebilirsin.',
+        'startFallback.messageHere': '{remote} uzak dalına ulaşılamadı. Görev, yereldeki {local} üzerinden bu klasörde başlasın mı?',
+        'startFallback.messageWorktree': '{remote} uzak dalına ulaşılamadı. Görev, yereldeki {local} üzerinden ayrı bir worktree’de başlasın mı?',
+        'statusMeaning.clear.description': 'Boş bırakma tercihini son incelemede doğrula; diğer alanlar aynı kalır.',
+        'statusMeaning.clear.label': 'Bu alanı boşalt',
+        'statusMeaning.context': 'Bu adım isteğe bağlı. Yorum veya açıklama isteği kaydedilmez; yazdığın tanımı son incelemeden sonra kaydederiz.',
+        'statusMeaning.current': 'Mevcut metin',
+        'statusMeaning.defer.description': 'Bu denemeyi ertele; kolon tanımını ve işleri değiştirme.',
+        'statusMeaning.defer.label': 'Şimdi kaydetme',
+        'statusMeaning.empty': '(boş)',
+        'statusMeaning.fields.entryRule.example': 'İncelemeye geçmek için kod hazır ve ilgili testler başarılı olmalı.',
+        'statusMeaning.fields.entryRule.inputTitle': 'Yazmak istediğin giriş koşulu',
+        'statusMeaning.fields.entryRule.question': 'Bir iş bu kolona hangi koşulda alınır?',
+        'statusMeaning.fields.entryRule.title': 'Kolona giriş koşulu',
+        'statusMeaning.fields.meaning.example': 'İncelemede: geliştirme bitti; ekip arkadaşının kodu incelemesi bekleniyor.',
+        'statusMeaning.fields.meaning.inputTitle': 'Yazmak istediğin anlam',
+        'statusMeaning.fields.meaning.question': 'Bu kolondaki iş ne aşamada olur?',
+        'statusMeaning.fields.meaning.title': 'Kolonun anlamı',
+        'statusMeaning.keep.description': 'Bu alanı ve mevcut işleri değiştirme.',
+        'statusMeaning.keep.label': 'Mevcut kalsın',
+        'statusMeaning.next.description': 'Metnin sonraki kısmını göster; henüz hiçbir şey kaydetme.',
+        'statusMeaning.next.label': 'Devamını incele',
+        'statusMeaning.page': 'Sayfa',
+        'statusMeaning.proposed': 'Yeni metin',
+        'statusMeaning.review.context': 'Mevcut ve yeni metin tümüyle gösterilir. Uzunsa sonraki sayfaya geç; kaydetme yalnızca son sayfadadır. Bu işlem bir işi taşımaz veya olay çalıştırmaz.',
+        'statusMeaning.review.example': 'İncelemede kolonunu “kod hazır, inceleme bekleniyor” diye tanımlarsın. Kolondaki işler aynı yerde kalır.',
+        'statusMeaning.review.message': 'Bu alanın değişikliğini incele',
+        'statusMeaning.save.description': 'İncelediğin alanı kaydet; diğer alanlara ve mevcut işlere dokunma.',
+        'statusMeaning.save.label': 'Bu tanımı kaydet',
+        'statusMeaning.write.description': 'Metin alanına kendi tanımını yaz; kaydetmeden önce birlikte gözden geçir.',
+        'statusMeaning.write.label': 'Tanımı yaz',
+        'statusRemap.apply.description': 'Gösterilen işleri tek işlemde yeni kolonlarına taşı; kolon tanımlarına ve rollere dokunma.',
+        'statusRemap.apply.label': 'İşleri taşı',
+        'statusRemap.archived': 'arşivde',
+        'statusRemap.context': 'Her satır bir kolondaki bütün işlerin nereye taşınacağını ve kaç iş olduğunu gösterir. Onay bu sayılara bağlıdır: uygulama anında sayılar değişmişse hiçbir iş taşınmaz ve yeniden sorulur. Kolon tanımları ve roller değişmez.',
+        'statusRemap.defer.description': 'Hiçbir işi taşıma; bu deneme ertelenmiş olarak kalır.',
+        'statusRemap.defer.label': 'Şimdi taşıma',
+        'statusRemap.example': 'Staging Check kolonundaki 3 açık ve 1 arşivlenmiş iş READY FOR QA kolonuna geçer; işlerin sırası, başlığı ve diğer alanları aynı kalır.',
+        'statusRemap.message': 'Bu işleri yeni kolonlarına taşıyalım mı?',
+        'statusRemap.next.description': 'Taşımanın sonraki kısmını göster; henüz hiçbir işi taşıma.',
+        'statusRemap.next.label': 'Devamını incele',
+        'statusRemap.open': 'açık',
+        'statusRemap.page': 'Sayfa',
+        'statusRemap.reason': 'Neden',
+        'statusRemap.roles.all_prs_merged': 'Bütün PR’lar birleşti',
+        'statusRemap.roles.blocked_declared': 'Park edilen işler',
+        'statusRemap.roles.draft_pr_opened': 'Taslak PR',
+        'statusRemap.roles.pr_opened': 'İncelemeye hazır PR',
+        'statusRemap.roles.test_failed': 'Başarısız test',
+        'statusRemap.roles.work_started': 'Geliştirmeye başlama',
+        'statusRemap.rolesStay': 'Bu roller taşınan kolonları hedeflemeye devam eder; değiştirmek için rol kurulumu ayrıca yapılır:',
+        'taskStart.base.fetchDetail': 'Güncel hali çekilir.',
+        'taskStart.base.field': 'origin dalı (yalnızca başka dal için)',
+        'taskStart.base.local': 'Yerel: {branch}',
+        'taskStart.base.localDetail': 'Çekmeden, mevcut commit’ten.',
+        'taskStart.base.message': 'Hangi daldan başlayalım?',
+        'taskStart.base.other': 'origin üzerinde başka dal',
+        'taskStart.base.otherDetail': 'Alttaki alana yaz.',
+        'taskStart.example': 'Ayrı worktree, işi ayrı klasörde tutar.',
+        'taskStart.keepContext': 'Mevcut dalda devam edilecek.',
+        'taskStart.location.busy': '{task} bu klasörde başka bir oturumda hâlâ çalışıyor; yeni branch burada açılamaz. O oturumda duraklatılırsa bu klasör de seçilebilir.',
+        'taskStart.location.defer.description': 'Hiçbir şey oluşturulmaz.',
+        'taskStart.location.defer.label': 'Şimdilik başlatma',
+        'taskStart.location.dirty': 'Bu klasörde kaydedilmemiş değişiklikler var; yeni branch burada açılamaz.',
+        'taskStart.location.here.description': 'Klasör yeni dala geçer.',
+        'taskStart.location.here.label': 'Bu klasörde yeni dal',
+        'taskStart.location.holder': 'Bu klasördeki {task} görevi burada başlarsan ayrı worktree’ye geçer; işi korunur.',
+        'taskStart.location.keep.description': '{branch} üzerinde devam et.',
+        'taskStart.location.keep.label': 'Mevcut dalda kal',
+        'taskStart.location.message': 'Nerede çalışalım?',
+        'taskStart.location.worktree.description': 'Bu klasör değişmez.',
+        'taskStart.location.worktree.label': 'Ayrı worktree',
+        'taskStart.message': 'Göreve başla',
+        'taskStart.newBranch': 'Yeni dal: {name}',
+        'taskStart.stay': 'Yeni bir şey oluşturulmaz. İş bu klasörde {source} üzerinde sürer; her commit o dala gider.',
+        'uiWaiver.ask': '{task}: bu görev için UI kontrolünü (widget, golden veya ekran görüntüsü testi) atlayalım mı?',
+        'uiWaiver.context': 'UI kontrolü, bu görevde değişen ekranların hâlâ doğru çizildiğini gösteren testtir. Atlarsan bu görevde o ekranları açan hiçbir test kalmaz ve atlama kararı yukarıdaki gerekçesiyle görevin denetim kaydına yazılır.',
+        'uiWaiver.example': 'Bu değişiklikte bozulan bir yerleşim doğrulamadan geçer ve ancak uygulamayı açan biri fark ettiğinde ortaya çıkar.',
+        'uiWaiver.files': 'Arayüzü çizen değişen dosyalar: {files}',
+        'uiWaiver.reason': 'Verdiğin gerekçe: {reason}',
+        'uiWaiver.require.description': 'Hiçbir şey atlanmaz. Bu dosyaları kapsayan bir widget, golden veya ekran görüntüsü testi gelene kadar görev doğrulanmaz.',
+        'uiWaiver.require.label': 'UI kontrolü zorunlu kalsın',
+        'uiWaiver.waive.description': 'Görev, bu dosyalar için widget, golden veya ekran görüntüsü testi olmadan doğrulanır ve atlama kaydedilir.',
+        'uiWaiver.waive.label': 'UI kontrolünü atla',
+        'whatsNew.badge': '{count} yenilik · Paket {version}',
+        'whatsNew.build': 'Build {number}',
+        'whatsNew.example': 'Günlük kullanımda',
+        'whatsNew.footer': 'Tarihler, yeniliklerin bu katalogda ilk duyurulduğu günü gösterir. Bu yerel rapor, oluşturulduğu andaki bilgileri içerir; görevine normal şekilde devam edebilirsin.',
+        'whatsNew.intro': 'Kullandığın paketle erişebildiğin yenilikler ve günlük işlerinde sana nasıl yardımcı oldukları.',
+        'whatsNew.title': "EM'de neler yeni?",
+        'workflow.approve.description': 'Gösterilen beş tercihi birlikte kaydet; mevcut işleri taşıma.',
+        'workflow.approve.label': 'Bu ayarları kaydet',
+        'workflow.defer.description': 'Seçimleri uygulama; bu deneme ertelenmiş olarak kalır.',
+        'workflow.defer.label': 'Şimdi kaydetme',
+        'workflow.modes.automatic': 'Otomatik',
+        'workflow.modes.confirm': 'Onay sor',
+        'workflow.modes.ignore': 'Olayı dikkate alma',
+        'workflow.next.description': 'Aynı kararın sonraki kolonlarını göster.',
+        'workflow.next.label': 'Sonraki kolonlar',
+        'workflow.page': 'Sayfa',
+        'workflow.previous.description': 'Aynı kararın önceki kolonlarına dön.',
+        'workflow.previous.label': 'Önceki kolonlar',
+        'workflow.review.context': 'Beş kolon ve davranış aşağıda. Taslak PR ve yeni işin başlangıç kolonu değişmez. Bu işlem yalnızca ayarları kaydeder; olay çalıştırmaz.',
+        'workflow.review.example': 'Beklemeye alınan işler için Beklemede kolonunu seçtiysen proje bundan sonra bu tercihi saklar; önceki işler yerinde kalır.',
+        'workflow.review.message': 'Bu akış ayarlarını birlikte kaydedelim mi?',
+        'workflow.roles.all_prs_merged.context': 'Bu işe bağlı bütün PR’ların birleştiği adımı ayarlıyoruz.',
+        'workflow.roles.all_prs_merged.example': 'Hem web hem sunucu değişiklikleri birleştirildiğinde kullanılacak kolon.',
+        'workflow.roles.all_prs_merged.message': 'İşin bütün PR’ları birleşince hangi kolon kullanılsın?',
+        'workflow.roles.all_prs_merged.title': 'Bütün PR’lar birleşti',
+        'workflow.roles.blocked_declared.context': 'Projenin aktif park kolonunu seçiyoruz; mevcut işler yerinde kalacak.',
+        'workflow.roles.blocked_declared.example': 'Dış servisten yanıt beklediğin için işi beklemeye aldığında kullanılacak kolon.',
+        'workflow.roles.blocked_declared.message': 'Beklemeye alınan işler hangi kolonda park edilsin?',
+        'workflow.roles.blocked_declared.title': 'Park edilen işler',
+        'workflow.roles.pr_opened.context': 'Taslak PR davranışı aynı kalır; burada incelemeye hazır PR adımını ayarlıyoruz.',
+        'workflow.roles.pr_opened.example': 'Değişikliğini bitirip ekip arkadaşının incelemesine açtığında kullanılacak kolon.',
+        'workflow.roles.pr_opened.message': 'PR incelemeye hazır olunca hangi kolon kullanılsın?',
+        'workflow.roles.pr_opened.title': 'İncelemeye hazır PR',
+        'workflow.roles.test_failed.context': 'Başarısız testin ardından yapılacak düzeltmeler için kolon seçiyoruz.',
+        'workflow.roles.test_failed.example': 'Ödeme testinde hata bulundu; düzeltme bekleyen iş için kullanılacak kolon.',
+        'workflow.roles.test_failed.message': 'Test başarısız olunca hangi kolon kullanılsın?',
+        'workflow.roles.test_failed.title': 'Başarısız test',
+        'workflow.roles.work_started.context': 'Yeni işin açıldığı kolondan ayrı olarak, geliştirmeye başlama adımını ayarlıyoruz.',
+        'workflow.roles.work_started.example': 'Ödeme hatasını düzeltmeye başladığında kullanılacak kolonu seçiyorsun.',
+        'workflow.roles.work_started.message': 'Geliştirmeye başlayınca hangi kolon kullanılsın?',
+        'workflow.roles.work_started.title': 'Geliştirme',
+    },
+};
+//# sourceMappingURL=catalogue.generated.js.map