engineering-memory 1.11.11 → 1.11.13

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

@@ -31,6 +31,13 @@ export async function resumeQuestionnaire(server, service, input, context) {
 }
 export async function answerQuestionnaireFromHost(service, input) {
     try {
+        if (input.answer?.choice === explain) {
+            const record = await service.questionnaireResume(input);
+            if (record.status === 'pending' &&
+                record.requestKey === input.requestKey &&
+                record.contentHash === input.contentHash)
+                return pending(record, 'needs_explanation');
+        }
         const resolved = await service.questionnaireAnswerFromHost(input);
         return answered(resolved.record, resolved.answer, resolved.replayed, resolved.retry);
     }
@@ -59,6 +66,10 @@ async function present(server, service, record, repoRoot, context, preparation,
     const response = inputResponse(responses, record.requestKey);
     if (response.kind === 'elicit' && response.action === 'accept') {
         const content = acceptedContent(responses, record.requestKey);
+        if (content?.choice === explain || content?.[explain] === true) {
+            consumedResponses(context).add(record.requestKey);
+            return pending(record, 'needs_explanation');
+        }
         const parsed = questionnaireAnswerSchema(record).safeParse(record.questions && content ? formAnswers(record, content) : content);
         const answer = parsed.success ? parsed.data : undefined;
         if (!answer)
@@ -85,10 +96,9 @@ async function present(server, service, record, repoRoot, context, preparation,
     const elicitation = capabilities?.elicitation;
     if (!elicitation || (!elicitation.form && elicitation.url !== undefined))
         return pending(record, 'native_form_unavailable');
-    const copy = questionnaireCopy[record.language ?? 'en'];
+    const copy = copyFor(record);
     if (record.questions) {
         const properties = {};
-        const required = [];
         for (const sub of record.questions) {
             properties[sub.id] = {
                 type: 'string',
@@ -96,7 +106,6 @@ async function present(server, service, record, repoRoot, context, preparation,
                 enum: sub.options.map((option) => option.id),
                 enumNames: sub.options.map((option) => option.label),
             };
-            required.push(sub.id);
             if (sub.textField)
                 properties[`${sub.id}_text`] = {
                     type: 'string',
@@ -105,12 +114,13 @@ async function present(server, service, record, repoRoot, context, preparation,
                     maxLength: sub.textField.maxLength,
                 };
         }
+        properties[explain] = { type: 'boolean', title: copy.explain };
         return inputRequired({
             inputRequests: {
                 [record.requestKey]: inputRequired.elicit({
                     mode: 'form',
                     message: presentationMessage(record),
-                    requestedSchema: { type: 'object', properties, required },
+                    requestedSchema: { type: 'object', properties },
                 }),
             },
         });
@@ -129,10 +139,12 @@ async function present(server, service, record, repoRoot, context, preparation,
                             enum: [
                                 ...record.options.map((option) => option.id),
                                 ...(record.allowFreeText ? ['__other__'] : []),
+                                explain,
                             ],
                             enumNames: [
                                 ...record.options.map((option) => option.label),
                                 ...(record.allowFreeText ? [copy.other] : []),
+                                copy.explain,
                             ],
                         },
                         ...(record.allowFreeText
@@ -162,6 +174,7 @@ async function present(server, service, record, repoRoot, context, preparation,
         },
     });
 }
+const explain = '__explain__';
 const consumed = new WeakMap();
 function consumedResponses(context) {
     const keys = consumed.get(context.mcpReq) ?? new Set();
@@ -173,7 +186,9 @@ const questionnaireCopy = {
         pending: 'Choose an answer to resolve this decision. Closing or cancelling the form leaves it pending.',
         freeText: ' For another answer choose Other and fill in text. 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.',
-        multi: ' AskUserQuestion takes up to 4 questions per call. Show every question in as few calls as needed, then relay all answers in one questionnaire.answer_from_host.',
+        everyQuestion: ' Answer every question before submitting, unless you pick an option that ends the form.',
+        example: 'Example',
+        explain: 'I did not understand; explain in more detail first',
         answer: 'Answer',
         other: 'Other',
         otherAnswer: 'Other answer',
@@ -182,7 +197,9 @@ const questionnaireCopy = {
         pending: 'Kararını kaydetmek için bir seçenek seç. Formu kapatmak veya iptal etmek onay sayılmaz; soru beklemede kalır.',
         freeText: ' Farklı bir yanıt için Diğer seçeneğini seçip metin alanını doldur. 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.',
-        multi: ' AskUserQuestion tek çağrıda en fazla 4 soru alır. Her soruyu en az çağrıyla göster, sonra tüm yanıtları tek bir questionnaire.answer_from_host çağrısında ilet.',
+        everyQuestion: ' Göndermeden önce her soruyu cevapla; formu bitiren bir seçenek seçtiysen gerekmez.',
+        example: 'Örnek',
+        explain: 'Anlamadım; önce daha ayrıntılı anlat',
         answer: 'Yanıt',
         other: 'Diğer',
         otherAnswer: 'Diğer yanıt',
@@ -204,11 +221,29 @@ function formAnswers(record, content) {
     return answers;
 }
 function presentationMessage(record) {
-    const notice = /^memory-batch-[a-f0-9]{64}-[0-9]+$/.test(record.questionnaireId)
-        ? 'For an unversioned project proposal, approval updates legacy memory only. Source-aware tasks cannot read it until an inspection explicitly retains it. Check each sourceApplicabilityNotice in memory.list_proposals before approving.'
-        : undefined;
-    const copy = questionnaireCopy[record.language ?? 'en'];
-    return `${record.message}${notice ? `\n\n${notice}` : ''}\n\n${copy.pending}${record.allowFreeText ? copy.freeText : ''}${record.textField ? copy.storedText : ''}${record.questions ? copy.multi : ''}`;
+    const copy = copyFor(record);
+    const explained = (item) => [
+        item.context,
+        item.example && `${copy.example}: ${item.example}`,
+        (item.options ?? [])
+            .filter((option) => option.description)
+            .map((option) => `${option.label}: ${option.description}`)
+            .join('\n'),
+    ];
+    return [
+        record.message,
+        ...explained(record),
+        ...(record.questions ?? []).flatMap((sub) => {
+            const details = explained(sub).filter(Boolean);
+            return details.length ? [sub.message, ...details] : [];
+        }),
+        `${copy.pending}${record.questions ? copy.everyQuestion : ''}${record.allowFreeText ? copy.freeText : ''}${record.textField ? copy.storedText : ''}`,
+    ]
+        .filter(Boolean)
+        .join('\n\n');
+}
+function copyFor(record) {
+    return questionnaireCopy[record.language?.startsWith('tr') ? 'tr' : 'en'];
 }
 function pending(record, reason) {
     return result({
@@ -233,13 +268,17 @@ function pending(record, reason) {
                     allowFreeText: record.allowFreeText,
                     ...(record.textField ? { textField: record.textField } : {}),
                 }),
-            instructions: record.questions
+            instructions: `${record.questions
                 ? 'Only if the host permits a blocking native control for this decision, display every question, its options and notices in AskUserQuestion or request_user_input, one call at a time if needed. Relay every answer together in one questionnaire.answer_from_host call as `answers`, keyed by question id. Closing, declining, timeout, prose consent and missing answers are not native answers for any question. Do not reopen a dismissed question in a loop or label decline as proof of host incompatibility. The relay records agent-reported provenance, not MCP transport attestation. Retry the owning operation after acceptance; its authority and version checks still apply.'
-                : 'Only if the host permits a blocking native control for this decision, display this exact question, all options and notices in AskUserQuestion or request_user_input. Relay only the actual returned answer with these unchanged bindings. Closing, declining, timeout, prose consent and missing answers are not native answers. Do not reopen a dismissed question in a loop or label decline as proof of host incompatibility. The relay records agent-reported provenance, not MCP transport attestation. Retry the owning operation after acceptance; its authority and version checks still apply.',
+                : 'Only if the host permits a blocking native control for this decision, display this exact question, all options and notices in AskUserQuestion or request_user_input. Relay only the actual returned answer with these unchanged bindings. Closing, declining, timeout, prose consent and missing answers are not native answers. Do not reopen a dismissed question in a loop or label decline as proof of host incompatibility. The relay records agent-reported provenance, not MCP transport attestation. Retry the owning operation after acceptance; its authority and version checks still apply.'} Show each option's description under its label. If the person says they did not understand, including through the control's free-text answer, that is not an answer: call questionnaire.answer_from_host with answer {choice: "${explain}"} and the same bindings, and the decision stays pending.${(record.options?.length ?? 0) > 4
+                ? ' The host control shows fewer options than this question has: show them three at a time with one more option that reveals the rest, and relay only the final pick.'
+                : ''}`,
         },
-        nextAction: reason === 'native_form_unavailable'
-            ? 'This host does not advertise native MCP forms. The decision remains pending. Explain the limitation and continue only independently authorized work. Use hostFallback only with a permitted blocking native control; otherwise keep pending. Never substitute an asynchronous question.'
-            : 'The decision remains pending without expiry. Call questionnaire.resume with this questionnaireId to show the same question again. Do not infer an answer or continue dependent work.',
+        nextAction: reason === 'needs_explanation'
+            ? 'The person asked for more detail and the decision is still pending. Explain in chat, in their language, why this is asked, what each option does next and one concrete example. Then show the same question once more with questionnaire.resume. Do not infer an answer.'
+            : reason === 'native_form_unavailable'
+                ? 'This host does not advertise native MCP forms. The decision remains pending. Explain the limitation and continue only independently authorized work. Use hostFallback only with a permitted blocking native control; otherwise keep pending. Never substitute an asynchronous question.'
+                : 'The decision remains pending without expiry. Call questionnaire.resume with this questionnaireId to show the same question again. Do not infer an answer or continue dependent work.',
     });
 }
 function answered(record, answer, replayed, retry) {

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

@@ -1,6 +1,7 @@
 import * as z from 'zod/v4';
 import { validationIds } from '../runtime/bridge-service.js';
-import { hostAnswerSchema, questionnaireDefinitionSchema } from '../runtime/questionnaire-store.js';
+import { stableStringify } from '../utilities/hash.js';
+import { hostAnswerSchema, languageTag, questionnaireDefinitionSchema, } from '../runtime/questionnaire-store.js';
 import { answerChoice, answerQuestionnaireFromHost, askQuestionnaire, resumeQuestionnaire, } from './questionnaire-tools.js';
 const optionalRepoRoot = z.string().min(1).optional();
 const stringList = z.array(z.string().min(1));
@@ -156,6 +157,38 @@ 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.',
+        ],
+    },
+};
 export function registerQuestionnaireTools(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.',
@@ -195,13 +228,40 @@ export function registerQuestionnaireTools(server, service) {
         }
     });
     server.registerTool('questionnaire.ask', {
-        description: 'Persist a required decision before displaying a native questionnaire. Write the message and labels in the conversation language and set language (tr or en) for the native form help. Use a questionnaireId unique to this decision occurrence or task, and reuse it only for identical retries. A later decision or changed wording/options requires a new id. Only a schema-validated native acceptance answers it. Dismissal, timeout and missing replies remain pending without expiry. Never supply answers in questionnaire.ask arguments; use questionnaire.answer_from_host only after an actual permitted blocking native answer. Do not put personal information or secrets in the question or options. Free text is returned once and never stored; use explicit options for replayable decisions. After the first decline in this session, pass presentation host_native to skip the doomed elicitation round trip.',
+        description: 'Persist a required decision before displaying a native questionnaire. Write the message, context, example, labels and option descriptions in the language the user writes in, and set language to its BCP-47 tag (tr, en, pt-BR); it is remembered, and the call is refused while no language is known. Say why the decision is asked in context, give one concrete example of what it changes in example, and give every option a description of what happens next. Show a record by its title, never by an id or a hash. Use a questionnaireId unique to this decision occurrence or task, and reuse it only for identical retries. A later decision or changed wording/options requires a new id. Only a schema-validated native acceptance answers it. Dismissal, timeout and missing replies remain pending without expiry. Never supply answers in questionnaire.ask arguments; use questionnaire.answer_from_host only after an actual permitted blocking native answer. Do not put personal information or secrets in the question or options. Free text is returned once and never stored; use explicit options for replayable decisions. After the first decline in this session, pass presentation host_native to skip the doomed elicitation round trip.',
         inputSchema: questionnaireDefinitionSchema.extend({
             repoRoot: optionalRepoRoot,
             preparation: z.boolean().optional(),
             presentation: z.literal('host_native').optional(),
         }),
-    }, async (input, context) => await askQuestionnaire(server, service, input, context));
+    }, async (input, context) => {
+        if (!(await service.language(input.language)))
+            return toolResult({
+                ok: false,
+                error: {
+                    kind: 'bridge_error',
+                    message: 'Set language to the BCP-47 tag of the language the user is writing in, such as tr, en or pt-BR, and call questionnaire.ask again with otherwise identical arguments. It is remembered, so this is asked once.',
+                    retryable: true,
+                },
+            });
+        const shown = [input, ...(input.questions ?? [])].flatMap((question) => [
+            question.message,
+            question.context,
+            question.example,
+            question.textField?.title,
+            ...(question.options ?? []).flatMap((option) => [option.label, option.description]),
+        ]);
+        if (shown.some((text) => /\b[0-9a-f]{8}(?:-[0-9a-f]{4}){3}-[0-9a-f]{12}\b|[0-9a-f]{32,}/i.test(text?.replace(/`[^`]*`/g, '') ?? '')))
+            return toolResult({
+                ok: false,
+                error: {
+                    kind: 'bridge_error',
+                    message: 'The question shows an identifier or a hash where the person needs a name. Write the title of the record, branch or project instead; an identifier that has to be shown goes inside backticks. If this exact question is already pending, show it with questionnaire.resume instead.',
+                    retryable: true,
+                },
+            });
+        return await askQuestionnaire(server, service, input, context);
+    });
     server.registerTool('questionnaire.resume', {
         description: 'Display the original durable questionnaire after interruption or return its saved accepted choice. No timeout or dismissal resolves a pending question. A saved free-text receipt cannot replay the text and must never be treated as a recovered answer. presentation host_native returns the original question and bindings for a permitted blocking host control without reopening the MCP form.',
         inputSchema: z.strictObject({
@@ -240,7 +300,12 @@ export function registerEngineeringMemoryTools(server, service) {
     }, async (input) => toolResult(await service.auditList(input)));
     server.registerTool('session.entry', {
         description: 'The first call of every session in a repository, before answering anything about the project. Reports whether the user is signed in, whether this repository is bound, what this user decided about it last time, and the one thing to do now. A repository the user switched Engineering Memory off in reports that, and is left alone.',
-        inputSchema: z.object({ repoRoot: optionalRepoRoot }),
+        inputSchema: z.object({
+            repoRoot: optionalRepoRoot,
+            language: languageTag
+                .optional()
+                .describe('BCP-47 tag of the language the user is writing in, such as tr, en or pt-BR. It is remembered and every later form opens in it.'),
+        }),
     }, async (input) => toolResult(await service.sessionEntry(input)));
     server.registerTool('session.set_decision', {
         description: 'Record what the user decided about Engineering Memory in this repository: bound once they have chosen a project, disabled when they ask for it off, or none to forget the decision when they ask for it back. Call it only from something the user actually said; it is the only thing that changes the entry state.',
@@ -445,11 +510,11 @@ export function registerEngineeringMemoryTools(server, service) {
         }),
     }, async (input) => toolResult(await service.taskRecordCorrection(input)));
     server.registerTool('task.self_review', {
-        description: 'Record that each changed file was read back against the rules that govern it: one entry per changed file (deleted files excepted), naming every rule context.prepare_change returned for that path in governingRules, and for a file no role maps, the engineering rules you read it against. Each rule gets an outcome: follows; fixed, with the issue and the change you made; or user_accepted_deviation, with the rule resourceKey and the issue. A rule conflict is a question for the user, never a judgment call: for every deviation this tool asks the user natively whether to keep the code, records the deviation only on their approval, and refuses the review when they choose to change the code. Matching the surrounding code is not an outcome; existing code is evidence, not authority. Set language to the conversation language (tr or en) for the question. Returns a durable pending receipt without waiting for backend delivery; task.verify refuses until a review covers the current diff, so any further edit requires reviewing again.',
+        description: 'Record that each changed file was read back against the rules that govern it: one entry per changed file (deleted files excepted), naming every rule context.prepare_change returned for that path in governingRules, and for a file no role maps, the engineering rules you read it against. Each rule gets an outcome: follows; fixed, with the issue and the change you made; or user_accepted_deviation, with the rule resourceKey and the issue. A rule conflict is a question for the user, never a judgment call: for every deviation this tool asks the user natively whether to keep the code, records the deviation only on their approval, and refuses the review when they choose to change the code. Matching the surrounding code is not an outcome; existing code is evidence, not authority. Set language to the BCP-47 tag of the language the user writes in (tr, en, pt-BR); it is remembered. Returns a durable pending receipt without waiting for backend delivery; task.verify refuses until a review covers the current diff, so any further edit requires reviewing again.',
         inputSchema: z.object({
             repoRoot: optionalRepoRoot,
             taskId: z.string().min(1),
-            language: z.enum(['tr', 'en']).optional(),
+            language: languageTag.optional(),
             files: z
                 .array(z.object({
                 path: z.string().min(1).max(512),
@@ -478,19 +543,27 @@ 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 };
         let questions;
         try {
-            questions = service.ruleDeviationQuestions(input);
+            questions = await service.ruleDeviationQuestions(review);
         }
         catch {
-            return toolResult(await service.taskSelfReview(input));
+            return toolResult(await service.taskSelfReview(review));
         }
         for (const { definition, previousDefinitions } of questions) {
-            const form = await askQuestionnaire(server, service, { ...definition, repoRoot: input.repoRoot }, context, previousDefinitions);
+            const asked = { repoRoot: input.repoRoot, questionnaireId: definition.questionnaireId };
+            const stored = await service.questionnaireResume(asked).catch(() => undefined);
+            const form = stored && stableStringify(stored.binding) === stableStringify(definition.binding)
+                ? await resumeQuestionnaire(server, service, asked, context)
+                : await askQuestionnaire(server, service, { ...definition, repoRoot: input.repoRoot }, context, previousDefinitions);
             if (!answerChoice(form))
                 return form;
         }
-        return toolResult(await service.taskSelfReview(input));
+        return toolResult(await service.taskSelfReview(review));
     });
     server.registerTool('task.reconcile', {
         description: 'Reconcile changed screens and components with an approved revision or an explicit no-semantic-memory-change reason. Pass every record the task touched as `entries` in one call rather than calling once per record; the whole set is applied together and rejected together. After memory.review_proposal approves a proposal, pass its reconcileEntry ({resourceId, type: approved_revision, proposalId, revisionId}) straight through here — revisionId is optional and is resolved from the approved proposal when omitted. A pending result is a durable local receipt; continue independent work without polling. Required delivery is checked before verification.',
@@ -567,10 +640,9 @@ export function registerEngineeringMemoryTools(server, service) {
             repoRoot: optionalRepoRoot,
             taskId: z.string().min(1),
             sessionId: z.string().min(1),
-            language: z
-                .enum(['tr', 'en'])
+            language: languageTag
                 .optional()
-                .describe('Language of the current conversation, for the waiver question.'),
+                .describe('BCP-47 tag of the language the user writes in (tr, en, pt-BR), for the waiver question. It is remembered.'),
             leaseId: z.string().min(1).optional(),
             changedPaths: stringList.min(1).optional(),
             validations: z
@@ -603,7 +675,8 @@ export function registerEngineeringMemoryTools(server, service) {
                 .describe('Only when the user decides a required ui check is not needed for this change. Never inferred from prose; the tool asks the user and verifies only after they agree.'),
         }),
     }, async (input, context) => {
-        const { language = 'en', ...request } = input;
+        const { language: told, ...request } = input;
+        const language = (await service.language(told))?.startsWith('tr') ? 'tr' : 'en';
         for (const waiver of request.waivers ?? []) {
             const subject = await service.validationWaiverSubject({
                 repoRoot: request.repoRoot,
@@ -615,7 +688,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 = [
+            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 earlier = [
                 {
                     questionnaireId,
                     language: 'tr',
@@ -638,7 +725,7 @@ export function registerEngineeringMemoryTools(server, service) {
             const form = await askQuestionnaire(server, service, {
                 ...definitions.find((definition) => definition.language === language),
                 repoRoot: request.repoRoot,
-            }, context, definitions);
+            }, context, [...definitions, ...earlier]);
             const record = await service.questionnaireResume({
                 repoRoot: request.repoRoot,
                 questionnaireId,
@@ -843,15 +930,13 @@ export function registerEngineeringMemoryTools(server, service) {
         }),
     }, async (input) => toolResult(await service.workItemCreate(input)));
     server.registerTool('work_item.update', {
-        description: 'Edit or assign a work item at its current version. Assignees must already be active project members; this does not grant project access.',
+        description: "Edit or assign a work item at its current version. Assignees must already be active project members; this does not grant project access. Status is a slug from the project's own status catalogue; a backend that still keeps the six legacy values (backlog, ready, in_progress, in_review, done, cancelled) refuses anything else and names what it accepts.",
         inputSchema: z.object({
             ...workItemLocator,
             data: z.object({
                 ...workItemFields,
                 expectedVersion: z.number().int().min(1),
-                status: z
-                    .enum(['backlog', 'ready', 'in_progress', 'in_review', 'done', 'cancelled'])
-                    .optional(),
+                status: z.string().trim().min(1).max(64).optional(),
             }),
         }),
     }, async (input) => toolResult(await service.workItemUpdate(input)));
@@ -929,12 +1014,10 @@ export function registerEngineeringMemoryTools(server, service) {
         }),
     }, async (input) => toolResult(await service.projectUpdate(input)));
     server.registerTool('work_item.list', {
-        description: 'List selectable work items for a project before opening an engineering run in this chat.',
+        description: "List selectable work items for a project before opening an engineering run in this chat. The status filter is a slug from the project's own status catalogue; a backend that still keeps the six legacy values (backlog, ready, in_progress, in_review, done, cancelled) refuses anything else and names what it accepts.",
         inputSchema: z.object({
             projectId: z.string().uuid(),
-            status: z
-                .enum(['backlog', 'ready', 'in_progress', 'in_review', 'done', 'cancelled'])
-                .optional(),
+            status: z.string().trim().min(1).max(64).optional(),
             priority: z.enum(['lowest', 'low', 'medium', 'high', 'highest']).optional(),
             assigneeUserId: z.string().uuid().optional(),
             includeArchived: z.boolean().optional(),