engineering-memory 1.11.19 → 1.11.21

package/runtime/dist/src/mcp/questionnaire-tools.js

@@ -1,4 +1,6 @@
+import * as z from 'zod/v4';
 import { acceptedContent, CLIENT_CAPABILITIES_META_KEY, inputRequired, inputResponse, } from '@modelcontextprotocol/server';
+import { texts } from '../runtime/texts.js';
 import { questionnaireAnswerSchema, } from '../runtime/questionnaire-store.js';
 export async function askQuestionnaire(server, service, input, context, previousDefinitions = [], owner) {
     try {
@@ -233,30 +235,17 @@ function consumedResponses(context) {
     consumed.set(context.mcpReq, keys);
     return keys;
 }
-const questionnaireCopy = {
-    en: {
-        pending: 'Choose an answer to resolve this decision. Closing or cancelling the form leaves it pending.',
-        freeText: ' You can type a different answer without choosing an option. Free text is not stored and cannot be replayed.',
-        storedText: ' The bounded text field is stored as part of this exact decision and is replayed after restart.',
-        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.',
-        example: 'Example',
-        answer: 'Answer',
-        freeAnswer: 'Write another answer (optional)',
-        recommended: 'Recommended',
-        feedback: 'Write an answer or comment (optional)',
-    },
-    tr: {
-        pending: 'Kararını kaydetmek için bir seçenek seç. Formu kapatmak veya iptal etmek onay sayılmaz; soru beklemede kalır.',
-        freeText: ' Bir seçenek seçmeden farklı yanıtını yazabilirsin. Serbest yanıt saklanmaz ve daha sonra geri getirilemez.',
-        storedText: ' Bu metin alanındaki yanıt kararınla birlikte saklanır; yeniden başlattığında korunur.',
-        everyQuestion: ' Karar vermek için soruları cevapla veya formu bitiren bir seçenek seç. Hiçbir seçenek seçmeden yorum da gönderebilirsin.',
-        example: 'Örnek',
-        answer: 'Yanıt',
-        freeAnswer: 'Farklı yanıtını yaz (isteğe bağlı)',
-        recommended: 'Önerilen',
-        feedback: 'Yanıtını veya yorumunu yaz (isteğe bağlı)',
-    },
-};
+const questionnaireCopy = z.strictObject({
+    pending: z.string().min(1),
+    freeText: z.string().min(1),
+    storedText: z.string().min(1),
+    everyQuestion: z.string().min(1),
+    example: z.string().min(1),
+    answer: z.string().min(1),
+    freeAnswer: z.string().min(1),
+    recommended: z.string().min(1),
+    feedback: z.string().min(1),
+});
 function formAnswers(record, content) {
     const answers = {};
     for (const sub of record.questions ?? []) {
@@ -274,6 +263,8 @@ function formAnswers(record, content) {
 }
 function presentationMessage(record, compact = false) {
     const copy = copyFor(record);
+    if (record.owner?.tool === 'decision.mode' && record.binding)
+        return [record.message, record.context].filter(Boolean).join('\n');
     if (compact)
         return [
             record.message,
@@ -292,13 +283,21 @@ function presentationMessage(record, compact = false) {
     return [
         record.message,
         ...explained(record),
-        `${copy.pending}${record.questions ? copy.everyQuestion : ''}${record.allowFreeText ? copy.freeText : ''}${record.textField ? copy.storedText : ''}`,
+        [
+            copy.pending,
+            record.questions && copy.everyQuestion,
+            record.allowFreeText && copy.freeText,
+            record.textField && copy.storedText,
+        ]
+            .filter(Boolean)
+            .join(' '),
     ]
         .filter(Boolean)
         .join('\n\n');
 }
 function copyFor(record) {
-    return questionnaireCopy[record.language?.startsWith('tr') ? 'tr' : 'en'];
+    return (questionnaireCopy.safeParse(texts('questionnaire', record.language ?? 'en')).data ??
+        questionnaireCopy.parse(texts('questionnaire', 'en')));
 }
 function optionLabels(options, copy) {
     const recommended = options.find((option) => option.label.includes(`(${copy.recommended})`))?.id ?? options[0].id;

package/runtime/dist/src/mcp/status-meaning-tools.js

@@ -1,10 +1,14 @@
 import * as z from 'zod/v4';
 import { languageTag } from '../runtime/questionnaire-store.js';
 import { assertSafeToPersist } from '../runtime/offline-outbox.js';
+import { texts } from '../runtime/texts.js';
 import { sha256, stableStringify } from '../utilities/hash.js';
 import { answerChoice, answerData, askQuestionnaire } from './questionnaire-tools.js';
 const field = z.enum(['meaning', 'entryRule']);
-const navigation = z.tuple([z.string().trim().min(1).max(120), z.string().trim().min(1).max(200)]);
+const navigation = z.strictObject({
+    label: z.string().trim().min(1).max(120),
+    description: z.string().trim().min(1).max(200),
+});
 const wording = z.strictObject({
     fields: z.record(field, z.strictObject({
         title: z.string().trim().min(1).max(80),
@@ -61,87 +65,9 @@ const pageSchema = z.object({
     offset: z.number().int().min(0),
     limit: z.literal(100),
 });
-const copies = {
-    tr: {
-        fields: {
-            meaning: {
-                title: 'Kolonun anlamı',
-                question: 'Bu kolondaki iş ne aşamada olur?',
-                inputTitle: 'Yazmak istediğin anlam',
-                example: 'İncelemede: geliştirme bitti; ekip arkadaşının kodu incelemesi bekleniyor.',
-            },
-            entryRule: {
-                title: 'Kolona giriş koşulu',
-                question: 'Bir iş bu kolona hangi koşulda alınır?',
-                inputTitle: 'Yazmak istediğin giriş koşulu',
-                example: 'İncelemeye geçmek için kod hazır ve ilgili testler başarılı olmalı.',
-            },
-        },
-        context: 'Bu adım isteğe bağlı. Yorum veya açıklama isteği kaydedilmez; yazdığın tanımı son incelemeden sonra kaydederiz.',
-        current: 'Mevcut metin',
-        proposed: 'Yeni metin',
-        empty: '(boş)',
-        page: 'Sayfa',
-        keep: ['Mevcut kalsın', 'Bu alanı ve mevcut işleri değiştirme.'],
-        write: [
-            'Tanımı yaz',
-            'Metin alanına kendi tanımını yaz; kaydetmeden önce birlikte gözden geçir.',
-        ],
-        clear: [
-            'Bu alanı boşalt',
-            'Boş bırakma tercihini son incelemede doğrula; diğer alanlar aynı kalır.',
-        ],
-        next: ['Devamını incele', 'Metnin sonraki kısmını göster; henüz hiçbir şey kaydetme.'],
-        defer: ['Şimdi kaydetme', 'Bu denemeyi ertele; kolon tanımını ve işleri değiştirme.'],
-        save: [
-            'Bu tanımı kaydet',
-            'İncelediğin alanı kaydet; diğer alanlara ve mevcut işlere dokunma.',
-        ],
-        review: {
-            message: 'Bu alanın değişikliğini incele',
-            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.',
-            example: 'İncelemede kolonunu “kod hazır, inceleme bekleniyor” diye tanımlarsın. Kolondaki işler aynı yerde kalır.',
-        },
-    },
-    en: {
-        fields: {
-            meaning: {
-                title: 'Stage meaning',
-                question: 'What does work in this stage mean?',
-                inputTitle: 'Your stage meaning',
-                example: 'In Review: development is complete and a teammate needs to review the code.',
-            },
-            entryRule: {
-                title: 'Stage entry condition',
-                question: 'When should work enter this stage?',
-                inputTitle: 'Your entry condition',
-                example: 'Code must be ready and the relevant tests must pass before review.',
-            },
-        },
-        context: 'This step is optional. Feedback or requests for explanation do not save anything; a written definition is reviewed before saving.',
-        current: 'Current text',
-        proposed: 'New text',
-        empty: '(empty)',
-        page: 'Page',
-        keep: ['Keep the current value', 'Leave this field and existing work unchanged.'],
-        write: ['Write a definition', 'Enter your own text and review it before saving.'],
-        clear: ['Clear this field', 'Review an explicit empty value; other fields remain unchanged.'],
-        next: ['Review the next part', 'Show the next part of the text without saving anything yet.'],
-        defer: ['Do not save now', 'Defer this attempt without changing the stage or existing work.'],
-        save: [
-            'Save this definition',
-            'Save the reviewed field; other fields and existing work remain unchanged.',
-        ],
-        review: {
-            message: 'Review this field change',
-            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.',
-            example: 'Define In Review as “code is ready and awaiting review.” Tasks in that stage remain where they are.',
-        },
-    },
-};
 export function registerStatusMeaningTools(server, service) {
     server.registerTool('work_item.describe_status', {
-        description: 'Optionally review a user-authored meaning or entry condition for one status at its exact version. Resume the bound write task first. Never infer text from the name or resurvey owner-authored defaults. Supply a deliberate keep/write/clear recommendation and reason in the conversation language. Without draft, an editable native field collects up to2000 characters; explicitly authored draft arguments support the full4000-character metadata contract through complete review pages. Feedback alone never writes. Every saved change requires exact final mode-governed review, and existing metadata authority/version checks. Retry identical input to resume; reconsider a skipped/deferred attempt only when authorized. Turkish/English copy is built in; other languages require complete copy. Does not move work or fire events.',
+        description: 'Optionally review a user-authored meaning or entry condition for one status at its exact version. Resume the bound write task first. Never infer text from the name or resurvey owner-authored defaults. Supply a deliberate keep/write/clear recommendation and reason in the conversation language. Without draft, an editable native field collects up to2000 characters; explicitly authored draft arguments support the full4000-character metadata contract through complete review pages. Feedback alone never writes. Every saved change requires exact final mode-governed review, and existing metadata authority/version checks. Retry identical input to resume; reconsider a skipped/deferred attempt only when authorized. Copy comes from the product text catalogue when it has the conversation language; otherwise supply every copy field. Does not move work or fire events.',
         inputSchema,
     }, (input, context) => describeStatus(server, service, input, context));
 }
@@ -156,8 +82,8 @@ async function describeStatus(server, service, input, context) {
     catch {
         return refusal('Remove sensitive text from the description and its retry arguments.', 'work_item.describe_status');
     }
-    const primary = input.language.split('-')[0];
-    const copy = input.copy ?? (primary === 'tr' || primary === 'en' ? copies[primary] : undefined);
+    await service.language(input.language);
+    const copy = input.copy ?? wording.safeParse(texts('statusMeaning', input.language)).data;
     if (!copy)
         return refusal('Supply every copy field in the conversation language.', 'work_item.describe_status');
     let target;
@@ -219,8 +145,8 @@ async function describeStatus(server, service, input, context) {
         inputQuestionnaireId = 'status-description-input-' + setupId;
         const options = ['keep', 'write', 'clear'].map((id) => ({
             id,
-            label: copy[id][0],
-            description: copy[id][1] + (id === input.recommendation ? ' ' + input.reason : ''),
+            label: copy[id].label,
+            description: copy[id].description + (id === input.recommendation ? ' ' + input.reason : ''),
         }));
         options.sort((a, b) => Number(b.id === input.recommendation) - Number(a.id === input.recommendation));
         const question = {
@@ -312,8 +238,8 @@ async function describeStatus(server, service, input, context) {
             context: copy.review.context,
             example: copy.review.example,
             options: [
-                { id: final ? 'save' : 'continue', label: action[0], description: action[1] },
-                { id: 'defer', label: copy.defer[0], description: copy.defer[1] },
+                { id: final ? 'save' : 'continue', label: action.label, description: action.description },
+                { id: 'defer', label: copy.defer.label, description: copy.defer.description },
             ],
             binding: {
                 setupId,

package/runtime/dist/src/mcp/status-remap-tools.js

@@ -0,0 +1,252 @@
+import * as z from 'zod/v4';
+import { languageTag } from '../runtime/questionnaire-store.js';
+import { assertSafeToPersist } from '../runtime/offline-outbox.js';
+import { texts } from '../runtime/texts.js';
+import { sha256, stableStringify } from '../utilities/hash.js';
+import { answerChoice, askQuestionnaire } from './questionnaire-tools.js';
+const event = z.enum([
+    'work_started',
+    'draft_pr_opened',
+    'pr_opened',
+    'all_prs_merged',
+    'test_failed',
+    'blocked_declared',
+]);
+const navigation = z.strictObject({
+    label: z.string().trim().min(1).max(120),
+    description: z.string().trim().min(1).max(200),
+});
+const wording = z.strictObject({
+    message: z.string().trim().min(1).max(240),
+    context: z.string().trim().min(1).max(400),
+    example: z.string().trim().min(1).max(400),
+    open: z.string().trim().min(1).max(40),
+    archived: z.string().trim().min(1).max(40),
+    rolesStay: z.string().trim().min(1).max(240),
+    roles: z.record(event, z.string().trim().min(1).max(80)),
+    reason: z.string().trim().min(1).max(40),
+    page: z.string().trim().min(1).max(40),
+    next: navigation,
+    defer: navigation,
+    apply: navigation,
+});
+const inputSchema = z.strictObject({
+    repoRoot: z.string().min(1),
+    projectId: z.string().uuid(),
+    externalTaskId: z.string().trim().min(2).max(160),
+    requestKey: z.string().regex(/^[A-Za-z0-9_-]{1,80}$/),
+    expectedSnapshot: z.string().regex(/^[a-f0-9]{64}$/),
+    moves: z
+        .array(z.strictObject({ fromStatusId: z.string().uuid(), toStatusId: z.string().uuid() }))
+        .min(1)
+        .max(40)
+        .refine((values) => new Set(values.map((value) => value.fromStatusId)).size === values.length),
+    reason: z.string().trim().min(1).max(400),
+    language: languageTag,
+    copy: wording.optional(),
+    decisionAttempt: z.number().int().min(1).max(10000).optional(),
+    presentation: z.literal('host_native').optional(),
+});
+const stage = z.object({
+    id: z.string().uuid(),
+    name: z.string().min(1).max(120),
+    slug: z.string().min(1).max(64),
+    archivedAt: z.string().nullable(),
+    activeItems: z.number().int().min(0),
+    archivedItems: z.number().int().min(0),
+});
+const pageSchema = z.object({
+    snapshot: z.string().regex(/^[a-f0-9]{64}$/),
+    items: z.array(stage).max(100),
+    total: z.number().int().min(0),
+    offset: z.number().int().min(0),
+    limit: z.literal(100),
+    eventRules: z.array(z.object({
+        event,
+        targetStatus: z.object({ id: z.string().uuid() }).nullable(),
+    })),
+});
+export function registerStatusRemapTools(server, service) {
+    server.registerTool('work_item.remap_statuses', {
+        description: 'Move all work in chosen project stages to other active stages in one confirmed operation. Resume the bound write task and read every work_item.workflow page first; supply that exact snapshot, the explicit from/to stage pairs the user decided and a short reason in the conversation language. Sources may be archived stages; targets must be active; a stage cannot be both a source and a target. The review shows each group with its open and archived counts and any roles still aimed at a source stage; approval is bound to those counts and applies only if they are unchanged. It is critical under the task mode; feedback never applies it. Retry identical input to resume; reconsider a deferred attempt only when authorized. Copy comes from the product text catalogue when it has the conversation language; otherwise supply every copy field. Roles, stage definitions, order and archive state are not changed.',
+        inputSchema,
+    }, (input, context) => remapStatuses(server, service, input, context));
+}
+async function remapStatuses(server, service, input, context) {
+    const scope = await service.workItemSetupContext(input);
+    if (!scope.ok)
+        return output(scope);
+    const { repoRoot: _repoRoot, ...retryArguments } = input;
+    try {
+        assertSafeToPersist(retryArguments, '', '', true);
+    }
+    catch {
+        return refusal('Remove sensitive text from the reason and its retry arguments.', 'work_item.remap_statuses');
+    }
+    await service.language(input.language);
+    const copy = input.copy ?? wording.safeParse(texts('statusRemap', input.language)).data;
+    if (!copy)
+        return refusal('Supply every copy field in the conversation language.', 'work_item.remap_statuses');
+    const stages = [];
+    let rules = [];
+    let total;
+    for (let offset = 0; total === undefined || offset < total; offset += 100) {
+        const response = await service.workItemWorkflow({
+            projectId: input.projectId,
+            snapshot: input.expectedSnapshot,
+            includeArchived: true,
+            limit: 100,
+            offset,
+        });
+        if (!response.ok)
+            return output(response);
+        const parsed = pageSchema.safeParse(response.data);
+        if (!parsed.success)
+            return refusal('The workflow response is incomplete. Reload it before reviewing the move.', 'work_item.workflow');
+        const page = parsed.data;
+        if (page.snapshot !== input.expectedSnapshot ||
+            page.offset !== offset ||
+            (total !== undefined && page.total !== total) ||
+            page.items.length !== Math.min(100, Math.max(0, page.total - offset)))
+            return refusal('The workflow pages changed or were incomplete. Reload every page before reviewing the move.', 'work_item.workflow');
+        total = page.total;
+        rules = page.eventRules;
+        stages.push(...page.items);
+    }
+    const find = (id) => stages.find((item) => item.id === id);
+    const sourceIds = input.moves.map((move) => move.fromStatusId);
+    const targetIds = input.moves.map((move) => move.toStatusId);
+    if (new Set(stages.map((item) => item.id)).size !== stages.length ||
+        sourceIds.some((id) => targetIds.includes(id) || !find(id)) ||
+        targetIds.some((id) => find(id)?.archivedAt !== null))
+        return refusal('Move work from stages of this project to its active stages, without using a stage as both a source and a target.', 'work_item.workflow');
+    const moves = input.moves.map((move) => ({
+        ...move,
+        expectedActiveItems: find(move.fromStatusId).activeItems,
+        expectedArchivedItems: find(move.fromStatusId).archivedItems,
+    }));
+    if (moves.every((move) => move.expectedActiveItems + move.expectedArchivedItems === 0))
+        return output({ ok: true, data: { status: 'unchanged', applied: false } });
+    const label = (id) => find(id).name + ' (' + find(id).slug + ')';
+    const kept = rules
+        .filter((rule) => rule.targetStatus && sourceIds.includes(rule.targetStatus.id))
+        .map((rule) => copy.roles[rule.event] + ' → ' + label(rule.targetStatus.id));
+    const lines = [
+        ...moves.map((move) => label(move.fromStatusId) +
+            ' → ' +
+            label(move.toStatusId) +
+            ': ' +
+            copy.open +
+            ' ' +
+            move.expectedActiveItems +
+            ', ' +
+            copy.archived +
+            ' ' +
+            move.expectedArchivedItems),
+        ...(kept.length ? ['', copy.rolesStay, ...kept] : []),
+        '',
+        copy.reason + ': ' + input.reason,
+    ];
+    try {
+        assertSafeToPersist(lines, '', '', true);
+    }
+    catch {
+        return refusal('A stage name contains content that cannot be included in a durable question.', 'work_item.workflow');
+    }
+    const pages = [];
+    for (const line of lines) {
+        const last = pages.length - 1;
+        if (last >= 0 && pages[last].length + 1 + line.length <= 1400)
+            pages[last] += '\n' + line;
+        else
+            pages.push(line);
+    }
+    const namespace = scope.data.namespace;
+    const { presentation: _presentation, ...decisionInput } = retryArguments;
+    const proposal = {
+        projectId: input.projectId,
+        expectedSnapshot: input.expectedSnapshot,
+        moves,
+    };
+    const proposalDigest = sha256(stableStringify(proposal));
+    const setupId = sha256(stableStringify({ namespace, decisionInput, proposalDigest, pages }));
+    const reviewQuestionnaireIds = pages.map((_, index) => 'status-remap-review-' + sha256(stableStringify({ setupId, index })));
+    const owner = {
+        tool: 'work_item.remap_statuses',
+        externalTaskId: input.externalTaskId,
+        decisionAttempt: input.decisionAttempt,
+        retryArguments,
+    };
+    for (let index = 0; index < pages.length; index++) {
+        if (context.mcpReq.signal.aborted)
+            return output({ ok: true, data: { status: 'pending', reason: 'interrupted' } });
+        const final = index === pages.length - 1;
+        const action = final ? copy.apply : copy.next;
+        const question = {
+            questionnaireId: reviewQuestionnaireIds[index],
+            language: input.language,
+            impact: 'critical',
+            message: copy.message +
+                '\n\n' +
+                pages[index] +
+                '\n\n' +
+                copy.page +
+                ' ' +
+                (index + 1) +
+                '/' +
+                pages.length,
+            context: copy.context,
+            example: copy.example,
+            options: [
+                { id: final ? 'apply' : 'continue', label: action.label, description: action.description },
+                { id: 'defer', label: copy.defer.label, description: copy.defer.description },
+            ],
+            binding: { setupId, namespace, proposalDigest, reviewQuestionnaireIds, index },
+        };
+        const answer = await askQuestionnaire(server, service, { ...question, repoRoot: input.repoRoot, presentation: input.presentation }, context, [], owner);
+        const choice = answerChoice(answer);
+        if (choice === 'defer')
+            return deferred(input);
+        if (choice !== (final ? 'apply' : 'continue'))
+            return answer;
+    }
+    return output(await service.workItemApplyStatusRemap({
+        ...proposal,
+        repoRoot: input.repoRoot,
+        externalTaskId: input.externalTaskId,
+        reviewQuestionnaireIds,
+    }));
+}
+function deferred(input) {
+    return output({
+        ok: true,
+        data: {
+            status: 'deferred',
+            applied: false,
+            ...(input.decisionAttempt === 10000
+                ? {}
+                : {
+                    reconsider: {
+                        tool: 'work_item.remap_statuses',
+                        arguments: { ...input, decisionAttempt: (input.decisionAttempt ?? 0) + 1 },
+                    },
+                }),
+            nextAction: input.decisionAttempt === 10000
+                ? 'This attempt remains deferred. Use a new requestKey only after reconsideration is explicitly authorized.'
+                : 'No work was moved. Identical retries keep this deferral. Reconsider only after explicit user intent or a reasoned current delegated decision.',
+        },
+    });
+}
+function refusal(message, recovery) {
+    return output({
+        ok: false,
+        error: { kind: 'status_remap', message, recovery, retryable: false },
+    });
+}
+function output(result) {
+    return {
+        content: [{ type: 'text', text: JSON.stringify(result) }],
+        isError: !result.ok,
+    };
+}
+//# sourceMappingURL=status-remap-tools.js.map

package/runtime/dist/src/mcp/tool-annotations.js

@@ -111,6 +111,7 @@ export const toolAnnotations = {
     'work_item.configure_workflow': write,
     'work_item.setup_workflow': write,
     'work_item.describe_status': write,
+    'work_item.remap_statuses': write,
     'work_item.update_status': write,
     'work_item.create_status': write,
     'work_item.archive_status': write,

package/runtime/dist/src/mcp/tool-definitions.js

@@ -1,5 +1,6 @@
 import { registerDeliveryTools } from './delivery-tools.js';
 import { registerStatusMeaningTools } from './status-meaning-tools.js';
+import { registerStatusRemapTools } from './status-remap-tools.js';
 import { registerWorkflowTools } from './workflow-tools.js';
 import { registerReleaseTools } from './release-tools.js';
 import { ensureDecisionMode, registerDecisionTools } from './decision-tools.js';
@@ -8,6 +9,7 @@ import { validationIds } from '../runtime/bridge-service.js';
 import { stableStringify } from '../utilities/hash.js';
 import { hostAnswerSchema, languageTag, questionnaireDefinitionSchema, } from '../runtime/questionnaire-store.js';
 import { answerChoice, answerQuestionnaireFromHost, askFailed, askQuestionnaire, resumeQuestionnaire, } from './questionnaire-tools.js';
+import { copies, format } from '../runtime/texts.js';
 const optionalRepoRoot = z.string().min(1).optional();
 const stringList = z.array(z.string().min(1));
 const jsonValue = z.lazy(() => z.union([
@@ -146,6 +148,7 @@ export const engineeringMemoryToolNames = [
     'work_item.configure_workflow',
     'work_item.setup_workflow',
     'work_item.describe_status',
+    'work_item.remap_statuses',
     'work_item.update_status',
     'work_item.create_status',
     'work_item.archive_status',
@@ -178,43 +181,23 @@ const reconciliationEntry = z.object({
         .describe('Optional for approved_revision; resolved from the approved proposal when omitted.'),
     reason: z.string().optional(),
 });
-const waiverCopy = {
-    en: {
-        ask: (task) => `${task}: skip the UI check (widget, golden or screenshot test) for this task?`,
-        files: (listed) => `Changed files that draw the interface: ${listed}`,
-        reason: (reason) => `The reason you gave: ${reason}`,
-        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.',
-        example: 'A layout this change broke would pass verification and first show up when someone opens the app.',
-        waive: [
-            'Skip the UI check',
-            'The task verifies without a widget, golden or screenshot test of these files, and the skip is recorded.',
-        ],
-        require: [
-            'Keep the UI check required',
-            'Nothing is skipped. The task stays unverified until a widget, golden or screenshot test covers these files.',
-        ],
-    },
-    tr: {
-        ask: (task) => `${task}: bu görev için UI kontrolünü (widget, golden veya ekran görüntüsü testi) atlayalım mı?`,
-        files: (listed) => `Arayüzü çizen değişen dosyalar: ${listed}`,
-        reason: (reason) => `Verdiğin gerekçe: ${reason}`,
-        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.',
-        example: 'Bu değişiklikte bozulan bir yerleşim doğrulamadan geçer ve ancak uygulamayı açan biri fark ettiğinde ortaya çıkar.',
-        waive: [
-            'UI kontrolünü atla',
-            'Görev, bu dosyalar için widget, golden veya ekran görüntüsü testi olmadan doğrulanır ve atlama kaydedilir.',
-        ],
-        require: [
-            'UI kontrolü zorunlu kalsın',
-            'Hiçbir şey atlanmaz. Bu dosyaları kapsayan bir widget, golden veya ekran görüntüsü testi gelene kadar görev doğrulanmaz.',
-        ],
-    },
-};
+const text = z.string().min(1);
+const option = z.strictObject({ label: text, description: text });
+const waiverWording = z.strictObject({
+    ask: text,
+    files: text,
+    reason: text,
+    context: text,
+    example: text,
+    waive: option,
+    require: option,
+});
 export function registerQuestionnaireTools(server, service) {
     registerReleaseTools(server, service);
     registerDecisionTools(server, service);
     registerWorkflowTools(server, service);
     registerStatusMeaningTools(server, service);
+    registerStatusRemapTools(server, service);
     server.registerTool('questionnaire.answer_from_host', {
         description: 'Relay an actual answer from a host-permitted blocking native AskUserQuestion or request_user_input control to the exact durable question. First read hostFallback from the pending operation or questionnaire.resume with presentation host_native, display its unchanged question/options/notices and await the real native result. Never infer answers, use chat consent, asynchronous controls, defaults or a declined/dismissed form. The hostTool field is agent-reported provenance, not transport-verified attestation. Bind requestKey and contentHash exactly; changed scope, withdrawn questions, invalid or conflicting answers are refused. This only saves the answer; retry the owning operation for current authority and version checks.',
         inputSchema: hostAnswerSchema.extend({
@@ -576,10 +559,7 @@ export function registerEngineeringMemoryTools(server, service) {
                 .max(500),
         }),
     }, async (input, context) => {
-        const language = (await service.language(input.language))?.startsWith('tr')
-            ? 'tr'
-            : 'en';
-        const review = { ...input, language };
+        const review = { ...input, language: await service.language(input.language) };
         let questions;
         try {
             questions = await service.ruleDeviationQuestions(review);
@@ -709,7 +689,7 @@ export function registerEngineeringMemoryTools(server, service) {
         }),
     }, async (input, context) => {
         const { language: told, ...request } = input;
-        const language = (await service.language(told))?.startsWith('tr') ? 'tr' : 'en';
+        const wording = copies(waiverWording, 'uiWaiver', await service.language(told));
         for (const waiver of request.waivers ?? []) {
             const subject = await service.validationWaiverSubject({
                 repoRoot: request.repoRoot,
@@ -721,20 +701,21 @@ export function registerEngineeringMemoryTools(server, service) {
                 return toolResult(subject);
             const { questionnaireId, externalTaskId, paths, reason } = subject.data;
             const listed = paths.slice(0, 20).join(', ') + (paths.length > 20 ? ` (+${paths.length - 20})` : '');
-            const definitions = ['tr', 'en'].map((displayLanguage) => {
-                const copy = waiverCopy[displayLanguage];
-                return {
-                    questionnaireId,
-                    language: displayLanguage,
-                    message: [copy.ask(externalTaskId), copy.files(listed), copy.reason(reason)].join('\n'),
-                    context: copy.context,
-                    example: copy.example,
-                    options: [
-                        { id: 'waive', label: copy.waive[0], description: copy.waive[1] },
-                        { id: 'require', label: copy.require[0], description: copy.require[1] },
-                    ],
-                };
-            });
+            const definitions = wording.map(({ language, copy }) => ({
+                questionnaireId,
+                language,
+                message: [
+                    format(copy.ask, language, { task: externalTaskId }),
+                    format(copy.files, language, { files: listed }),
+                    format(copy.reason, language, { reason }),
+                ].join('\n'),
+                context: copy.context,
+                example: copy.example,
+                options: [
+                    { id: 'waive', label: copy.waive.label, description: copy.waive.description },
+                    { id: 'require', label: copy.require.label, description: copy.require.description },
+                ],
+            }));
             const earlier = [
                 {
                     questionnaireId,
@@ -755,10 +736,7 @@ export function registerEngineeringMemoryTools(server, service) {
                     ],
                 },
             ];
-            const form = await askQuestionnaire(server, service, {
-                ...definitions.find((definition) => definition.language === language),
-                repoRoot: request.repoRoot,
-            }, context, [...definitions, ...earlier]);
+            const form = await askQuestionnaire(server, service, { ...definitions[0], repoRoot: request.repoRoot }, context, [...definitions, ...earlier]);
             if (askFailed(form))
                 return form;
             const record = await service.questionnaireResume({