engineering-memory 1.11.9 → 1.11.11

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

@@ -1,13 +1,26 @@
 import { acceptedContent, CLIENT_CAPABILITIES_META_KEY, inputRequired, inputResponse, } from '@modelcontextprotocol/server';
 import { questionnaireAnswerSchema, } from '../runtime/questionnaire-store.js';
-export async function askQuestionnaire(server, service, input, context, previousDefinitions = []) {
+export async function askQuestionnaire(server, service, input, context, previousDefinitions = [], owner) {
     try {
-        return await present(server, service, await service.questionnaireAsk(input, previousDefinitions), input.repoRoot, context, input.preparation);
+        return await present(server, service, await service.questionnaireAsk(input, previousDefinitions, owner), input.repoRoot, context, input.preparation, input.presentation);
     }
     catch (error) {
         return failure(error);
     }
 }
+export function answerChoice(result) {
+    return answerData(result)?.choice;
+}
+export function answerData(result) {
+    const response = result;
+    const text = response.content?.find((item) => item.type === 'text')?.text;
+    if (!text)
+        return undefined;
+    const value = JSON.parse(text);
+    return value.ok && value.data?.status === 'answered' && value.data.answerAvailable
+        ? value.data.answer
+        : undefined;
+}
 export async function resumeQuestionnaire(server, service, input, context) {
     try {
         return await present(server, service, await service.questionnaireResume(input), input.repoRoot, context, input.preparation, input.presentation);
@@ -19,7 +32,7 @@ export async function resumeQuestionnaire(server, service, input, context) {
 export async function answerQuestionnaireFromHost(service, input) {
     try {
         const resolved = await service.questionnaireAnswerFromHost(input);
-        return answered(resolved.record, resolved.answer, resolved.replayed);
+        return answered(resolved.record, resolved.answer, resolved.replayed, resolved.retry);
     }
     catch (error) {
         return failure(error);
@@ -33,8 +46,11 @@ async function present(server, service, record, repoRoot, context, preparation,
             answerAvailable: false,
             nextAction: 'This decision was explicitly withdrawn. Do not continue dependent work. Use a new questionnaireId or onboarding requestKey only if the user resumes that work.',
         });
-    if (record.status === 'answered')
-        return answered(record, record.answer, true);
+    if (record.status === 'answered') {
+        if (inputResponse(context.mcpReq.inputResponses, record.requestKey).kind !== 'missing')
+            consumedResponses(context).add(record.requestKey);
+        return answered(record, record.questions ? record.answers : record.answer, true);
+    }
     if (context.mcpReq.signal.aborted)
         return pending(record, 'interrupted');
     if (presentation === 'host_native')
@@ -42,22 +58,27 @@ async function present(server, service, record, repoRoot, context, preparation,
     const responses = context.mcpReq.inputResponses;
     const response = inputResponse(responses, record.requestKey);
     if (response.kind === 'elicit' && response.action === 'accept') {
-        const answer = acceptedContent(responses, record.requestKey, questionnaireAnswerSchema(record));
+        const content = acceptedContent(responses, record.requestKey);
+        const parsed = questionnaireAnswerSchema(record).safeParse(record.questions && content ? formAnswers(record, content) : content);
+        const answer = parsed.success ? parsed.data : undefined;
         if (!answer)
             return pending(record, 'invalid_response');
+        consumedResponses(context).add(record.requestKey);
         const resolved = await service.questionnaireAccept({
             repoRoot,
             preparation,
             questionnaireId: record.questionnaireId,
             requestKey: record.requestKey,
             scope: record.scope,
-            answer,
+            answer: answer,
         });
         return answered(resolved.record, resolved.answer, resolved.replayed);
     }
     if (response.kind === 'elicit')
         return pending(record, response.action);
-    if (responses !== undefined || context.mcpReq.droppedInputResponseKeys?.length)
+    if (response.kind !== 'missing' ||
+        context.mcpReq.droppedInputResponseKeys?.length ||
+        Object.keys(responses ?? {}).some((key) => !consumedResponses(context).has(key)))
         return pending(record, 'missing_or_stale_response');
     const envelope = context.mcpReq.envelope;
     const capabilities = envelope?.[CLIENT_CAPABILITIES_META_KEY] ?? server.server.getClientCapabilities();
@@ -65,6 +86,35 @@ async function present(server, service, record, repoRoot, context, preparation,
     if (!elicitation || (!elicitation.form && elicitation.url !== undefined))
         return pending(record, 'native_form_unavailable');
     const copy = questionnaireCopy[record.language ?? 'en'];
+    if (record.questions) {
+        const properties = {};
+        const required = [];
+        for (const sub of record.questions) {
+            properties[sub.id] = {
+                type: 'string',
+                title: sub.message,
+                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',
+                    title: sub.textField.title,
+                    minLength: 1,
+                    maxLength: sub.textField.maxLength,
+                };
+        }
+        return inputRequired({
+            inputRequests: {
+                [record.requestKey]: inputRequired.elicit({
+                    mode: 'form',
+                    message: presentationMessage(record),
+                    requestedSchema: { type: 'object', properties, required },
+                }),
+            },
+        });
+    }
     return inputRequired({
         inputRequests: {
             [record.requestKey]: inputRequired.elicit({
@@ -112,11 +162,18 @@ async function present(server, service, record, repoRoot, context, preparation,
         },
     });
 }
+const consumed = new WeakMap();
+function consumedResponses(context) {
+    const keys = consumed.get(context.mcpReq) ?? new Set();
+    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: ' 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.',
         answer: 'Answer',
         other: 'Other',
         otherAnswer: 'Other answer',
@@ -125,17 +182,33 @@ 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.',
         answer: 'Yanıt',
         other: 'Diğer',
         otherAnswer: 'Diğer yanıt',
     },
 };
+function formAnswers(record, content) {
+    const answers = {};
+    for (const sub of record.questions ?? []) {
+        if (content[sub.id] === undefined)
+            continue;
+        const text = content[`${sub.id}_text`];
+        answers[sub.id] = {
+            choice: content[sub.id],
+            ...(text !== undefined && sub.textField?.requiredForChoice === content[sub.id]
+                ? { text }
+                : {}),
+        };
+    }
+    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 : ''}`;
+    return `${record.message}${notice ? `\n\n${notice}` : ''}\n\n${copy.pending}${record.allowFreeText ? copy.freeText : ''}${record.textField ? copy.storedText : ''}${record.questions ? copy.multi : ''}`;
 }
 function pending(record, reason) {
     return result({
@@ -149,25 +222,36 @@ function pending(record, reason) {
             requestKey: record.requestKey,
             contentHash: record.contentHash,
             message: presentationMessage(record),
-            options: record.options,
             language: record.language ?? 'en',
-            allowFreeText: record.allowFreeText,
-            ...(record.textField ? { textField: record.textField } : {}),
-            instructions: '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.',
+            ...(record.questions
+                ? {
+                    questions: record.questions,
+                    ...(record.terminalChoices ? { terminalChoices: record.terminalChoices } : {}),
+                }
+                : {
+                    options: record.options,
+                    allowFreeText: record.allowFreeText,
+                    ...(record.textField ? { textField: record.textField } : {}),
+                }),
+            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.',
         },
         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.',
     });
 }
-function answered(record, answer, replayed) {
+function answered(record, answer, replayed, retry) {
+    const key = record.questions ? 'answers' : 'answer';
     return result({
         questionnaireId: record.questionnaireId,
         status: 'answered',
         answerAvailable: answer !== undefined,
-        ...(answer ? { answer } : {}),
+        ...(answer ? { [key]: answer } : {}),
         replayed,
         ...(record.answerSource ? { answerSource: record.answerSource } : {}),
+        ...(retry ? { retry } : {}),
         ...(!answer
             ? {
                 nextAction: 'The free-text answer was accepted earlier but was not stored for privacy. It cannot be recovered or inferred. Use the original answer if still present in this conversation; otherwise collect it again through a new questionnaire or supported native input before dependent work.',

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

@@ -0,0 +1,112 @@
+const read = { readOnlyHint: true, openWorldHint: false }; // receipts and registry upkeep still read
+const write = {
+    readOnlyHint: false,
+    destructiveHint: false,
+    openWorldHint: false,
+};
+const repeatableWrite = { ...write, idempotentHint: true };
+const destructive = {
+    readOnlyHint: false,
+    destructiveHint: true,
+    openWorldHint: false,
+};
+const outward = {
+    readOnlyHint: false,
+    destructiveHint: false,
+    openWorldHint: true,
+};
+export const toolAnnotations = {
+    'project.git_preferences': read,
+    'project.set_git_preferences': write,
+    'worktree.policy': read,
+    'worktree.set_policy': write,
+    'worktree.list': read,
+    'worktree.reconcile': destructive, // releaseUnowned hands a recovered checkout back
+    'task.heartbeat': repeatableWrite,
+    'task.pause': write,
+    'worktree.release': destructive,
+    'audit.list': read,
+    'questionnaire.ask': repeatableWrite,
+    'questionnaire.resume': repeatableWrite, // records an accepted answer
+    'questionnaire.answer_from_host': repeatableWrite,
+    'questionnaire.withdraw': destructive,
+    'session.entry': read,
+    'session.set_decision': repeatableWrite,
+    'session.decline_update': repeatableWrite,
+    'session.answer_shadow_notice': repeatableWrite,
+    'session.bootstrap': write,
+    'session.resume': write,
+    'context.prepare_change': write,
+    'context.refresh': write,
+    'project.inspect': read,
+    'project.onboard': write,
+    'project.onboarding_status': read,
+    'project.rework_plan': write,
+    'project.initialize': write,
+    'memory.source': read,
+    'memory.sync_start': repeatableWrite,
+    'memory.sync_status': read,
+    'memory.sync_inventory': write,
+    'memory.sync_plan': write,
+    'memory.sync_next': write,
+    'memory.sync_submit': write,
+    'memory.sync_reopen': write,
+    'memory.sync_delta': read,
+    'memory.sync_verify': repeatableWrite,
+    'memory.catalog': read,
+    'memory.sources': read,
+    'memory.source_targets': read,
+    'memory.publish_task': write,
+    'memory.read_revisions': read,
+    'memory.review_batch': write,
+    'memory.query': read,
+    'memory.history': read,
+    'memory.propose_revision': write,
+    'memory.list_proposals': read,
+    'memory.review_proposal': write,
+    'task.checkpoint': write,
+    'task.record_correction': write,
+    'task.self_review': write,
+    'task.reconcile': write,
+    'task.resolve_pending_delivery': destructive, // discards a pending delivery
+    'task.verify': write,
+    'task.close': write,
+    'task.abandon': destructive,
+    'task.branch': outward, // fetches the chosen base from the Git remote
+    'architecture.plan': read,
+    'architecture.module': read,
+    'architecture.record_application': write,
+    'organization.list': read,
+    'organization.create': write,
+    'organization.update': write,
+    'organization.member_list': read,
+    'organization.member_upsert': write,
+    'project.setup': write,
+    'project.list': read,
+    'project.resolve': repeatableWrite, // binds an explicitly selected project
+    'project.move_repository': write,
+    'project.archive': destructive,
+    'project.restore': write,
+    'project.member_add': write,
+    'project.member_list': read,
+    'work_item.create': write,
+    'work_item.update': write,
+    'work_item.archive': destructive,
+    'work_item.restore': write,
+    'work_item.runs': read,
+    'work_item.record_test': write,
+    'work_item.test_results': read,
+    'work_item.plan': read,
+    'work_item.confirm_plan': write,
+    'project.update': write,
+    'work_item.list': read,
+    'work_item.get': read,
+    'project.clone': outward,
+    'project.link': write,
+    'project.unlink': destructive,
+    'project.links': read,
+    'auth.status': read,
+    'auth.signin_browser': outward,
+    'auth.logout': destructive,
+};
+//# sourceMappingURL=tool-annotations.js.map

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

@@ -1,7 +1,7 @@
 import * as z from 'zod/v4';
 import { validationIds } from '../runtime/bridge-service.js';
 import { hostAnswerSchema, questionnaireDefinitionSchema } from '../runtime/questionnaire-store.js';
-import { answerQuestionnaireFromHost, askQuestionnaire, resumeQuestionnaire, } from './questionnaire-tools.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));
 const jsonValue = z.lazy(() => z.union([
@@ -114,6 +114,7 @@ export const engineeringMemoryToolNames = [
     'project.setup',
     'project.list',
     'project.resolve',
+    'project.move_repository',
     'project.archive',
     'project.restore',
     'project.member_add',
@@ -149,7 +150,10 @@ const reconciliationEntry = z.object({
     resourceId: z.string().min(1),
     type: z.enum(['approved_revision', 'no_semantic_memory_change', 'scaffold_applied']),
     proposalId: z.string().optional(),
-    revisionId: z.string().optional(),
+    revisionId: z
+        .string()
+        .optional()
+        .describe('Optional for approved_revision; resolved from the approved proposal when omitted.'),
     reason: z.string().optional(),
 });
 export function registerQuestionnaireTools(server, service) {
@@ -191,10 +195,11 @@ 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.',
+        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.',
         inputSchema: questionnaireDefinitionSchema.extend({
             repoRoot: optionalRepoRoot,
             preparation: z.boolean().optional(),
+            presentation: z.literal('host_native').optional(),
         }),
     }, async (input, context) => await askQuestionnaire(server, service, input, context));
     server.registerTool('questionnaire.resume', {
@@ -259,14 +264,32 @@ export function registerEngineeringMemoryTools(server, service) {
         }),
     }, async (input) => toolResult(await service.sessionAnswerShadowNotice(input)));
     server.registerTool('session.bootstrap', {
-        description: 'Authenticate, resolve the repository project, open or resume a write or read-only task, and load mandatory engineering context before planning.',
+        description: 'Authenticate, resolve the repository project, open or resume a write or read-only task, and load mandatory engineering context before planning. objective is one line of at most 240 characters. contextPack holds only what fit the response budget; deferredResources lists what did not, each entry carrying its revisionId so it can be read directly with memory.read_revisions rather than looked up again through memory.catalog.',
         inputSchema: z.object({
             repoRoot: optionalRepoRoot,
             projectId: z.string().optional(),
-            externalTaskId: z.string().min(2),
-            objective: z.string().min(2),
-            taskKind: z.string().min(2),
-            workItemKey: z.string().min(1).optional(),
+            externalTaskId: z
+                .string()
+                .min(2)
+                .max(160)
+                .regex(/^[^\r\n]+$/, 'externalTaskId must be a single line of at most 160 characters.'),
+            objective: z
+                .string()
+                .min(2)
+                .max(240)
+                .regex(/^[^\r\n]+$/, 'objective must be a single line of at most 240 characters.')
+                .describe('One line, 2-240 characters: what this task delivers. Put detail in checkpoints, not here.'),
+            taskKind: z
+                .string()
+                .min(2)
+                .max(80)
+                .regex(/^[^\r\n]+$/, 'taskKind must be a single line of at most 80 characters.'),
+            workItemKey: z
+                .string()
+                .min(2)
+                .max(120)
+                .regex(/^[^\r\n]+$/, 'workItemKey must be a single line of at most 120 characters.')
+                .optional(),
             workItemId: z.string().uuid().optional(),
             mode: z.enum(['write', 'read_only', 'scaffold']).optional(),
             linkedSources: z
@@ -300,14 +323,14 @@ export function registerEngineeringMemoryTools(server, service) {
         }),
     }, async (input) => toolResult(await service.contextPrepareChange(input)));
     server.registerTool('context.refresh', {
-        description: 'Refresh pins within the task fixed code source after memory approval. Use the task repoRoot; source changes require a new task.',
+        description: 'Refresh pins within the task fixed code source after memory approval. Use the task repoRoot; source changes require a new task. contextPack carries only the revisions that changed since the session pinned them; unchangedResources lists the rest with the revisionId to reread one through memory.read_revisions, and deferredResources entries carry theirs too.',
         inputSchema: z.object({
             repoRoot: optionalRepoRoot,
             sessionId: z.string().min(1),
         }),
     }, async (input) => toolResult(await service.contextRefresh(input)));
     server.registerTool('memory.query', {
-        description: 'Read the smallest project memory pack needed for screens, components, services, navigation, localization or state work.',
+        description: 'Read the smallest project memory pack needed for screens, components, services, navigation, localization or state work. resources holds what fits one response; deferredResources lists the rest, each with the revisionId to read it through memory.read_revisions.',
         inputSchema: z.object({
             projectId: z.string().min(1),
             sessionId: z.string().min(1),
@@ -319,17 +342,19 @@ export function registerEngineeringMemoryTools(server, service) {
         }),
     }, async (input) => toolResult(await service.memoryQuery(input)));
     server.registerTool('memory.history', {
-        description: 'Read why the code you are about to change is the way it is: the revision history of the screen, component or contract records covering the given paths or keys, each revision with the task that produced it and the stated reason, plus the earlier tasks that touched those records and how many corrections each of them took. Also returns the task references found in the Git history of those paths. Verification refuses while a record with earlier work on it was never read.',
+        description: 'Read why the code you are about to change is the way it is: the revision history of the screen, component or contract records covering the given paths, keys or ids, each revision with the task that produced it and the stated reason, plus the earlier tasks that touched those records and how many corrections each of them took. Also returns the task references found in the Git history of those paths. Verification refuses while a record with earlier work on it was never read; required:true reads every such record of the current lease in one call. A path no record covers comes back in uncoveredPaths instead of an error.',
         inputSchema: z.object({
             repoRoot: optionalRepoRoot,
             sessionId: z.string().min(1),
             resourceKeys: z.array(z.string().min(1)).optional(),
+            resourceIds: z.array(z.string().uuid()).max(50).optional(),
             paths: z.array(z.string().min(1)).optional(),
+            required: z.boolean().optional(),
             depth: z.number().int().min(1).max(50).optional(),
         }),
     }, async (input) => toolResult(await service.memoryHistory(input)));
     server.registerTool('memory.propose_revision', {
-        description: 'Create an inactive, reviewable proposal for permanent product, organization or project memory. Do not block independent task work on drafting, submission or approval. Use authorized host background agents or concurrent tools and continue useful work; collect the result only before an operation needs its proposal or revision ID. Without concurrency, checkpoint the pending draft and defer this call until needed. Keep one writer per resource and preserve baseRevision and task/source identity. A response distinguishes stored (queued:false) from outbox-queued; neither means approved. Native user approval and task verification remain required.',
+        description: "Create an inactive, reviewable proposal for permanent product, organization or project memory. Do not block independent task work on drafting, submission or approval. Use authorized host background agents or concurrent tools and continue useful work; collect the result only before an operation needs its proposal or revision ID. Without concurrency, checkpoint the pending draft and defer this call until needed. Keep one writer per resource and preserve baseRevision and task/source identity. A response distinguishes stored (queued:false) from outbox-queued; neither means approved. A stored proposal reports reviewableByCaller: ask this user to approve it only when that is true; otherwise report it as submitted, with its id, to the reviewPath it names (product_release, organization_owner or project_maintainer). Task verification remains required. metadata carries only the structured fields the resource kind defines, such as a project profile's pathRoles, architecture and resourceDiscovery, appliesToStacks, or an architecture template's manifest; classification, containsPii, containsSecrets and resourceDescriptor are computed by the server and ignored when sent, so metadata copied from a served revision is accepted. A project profile's metadata.architecture, when present, is exactly {adopted: [{structure, pressure}], declined: [{structure, why}]} (structure up to 80 characters, pressure/why up to 600, at most 40 entries each) and no other key; a free-text style such as 'MVVM' is not that shape and goes in metadata.architectureStyle (a plain string) or the profile content instead.",
         inputSchema: z.object({
             repoRoot: optionalRepoRoot,
             sourceRunId: z.string().uuid().optional(),
@@ -374,10 +399,15 @@ export function registerEngineeringMemoryTools(server, service) {
         }),
     }, async (input) => toolResult(await service.memoryProposeRevision(input)));
     server.registerTool('memory.list_proposals', {
-        description: 'List the permanent memory proposals still waiting for review, so an authorized reviewer can find them without database access. Pass proposalId to read one proposal with its proposed content.',
+        description: "List the permanent memory proposals still waiting for review, so an authorized reviewer can find them without database access. Each entry carries a reasonPreview, not the full reason; pass proposalId to read one proposal in full, with its reason and proposed content. Narrow a long list with taskId, scope or status (defaults to pending); page through the rest with limit (default 50, max 100) and afterId, set to the response's nextAfterId to continue, which is null once nothing more is waiting. Each proposal reports reviewableByCaller; when it is false, the caller cannot approve it, so never ask this user for approval: report it as waiting on the reviewPath it names.",
         inputSchema: z.object({
             projectId: z.string().min(1),
             proposalId: z.string().min(1).optional(),
+            taskId: z.string().min(1).optional(),
+            scope: z.enum(['project', 'organization', 'product']).optional(),
+            status: z.enum(['pending', 'approved', 'rejected', 'superseded']).optional(),
+            afterId: z.string().min(1).optional(),
+            limit: z.number().int().min(1).max(100).optional(),
         }),
     }, async (input) => toolResult(await service.memoryListProposals(input)));
     server.registerTool('memory.review_proposal', {
@@ -415,21 +445,55 @@ export function registerEngineeringMemoryTools(server, service) {
         }),
     }, async (input) => toolResult(await service.taskRecordCorrection(input)));
     server.registerTool('task.self_review', {
-        description: 'Record that the changed code was read back against the rules that govern it, naming the knowledge resources reviewed and every conflict found with how it was resolved. Returns a durable pending receipt without waiting for backend delivery; continue independent local validation. task.verify waits for required delivery and refuses until this exists for 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 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.',
         inputSchema: z.object({
             repoRoot: optionalRepoRoot,
             taskId: z.string().min(1),
-            reviewedResourceIds: z.array(z.string().min(1)),
-            findings: z.array(z.object({
-                path: z.string().min(1),
-                rule: z.string().min(1),
-                issue: z.string().min(8),
-                resolution: z.string().min(8),
-            })),
+            language: z.enum(['tr', 'en']).optional(),
+            files: z
+                .array(z.object({
+                path: z.string().min(1).max(512),
+                rules: z
+                    .array(z.discriminatedUnion('outcome', [
+                    z.object({
+                        resourceId: z.string().uuid(),
+                        outcome: z.literal('follows'),
+                    }),
+                    z.object({
+                        resourceId: z.string().uuid(),
+                        outcome: z.literal('fixed'),
+                        issue: z.string().min(8).max(2000),
+                        change: z.string().min(8).max(2000),
+                    }),
+                    z.object({
+                        resourceId: z.string().uuid(),
+                        outcome: z.literal('user_accepted_deviation'),
+                        resourceKey: z.string().min(1).max(240),
+                        issue: z.string().min(8).max(1000),
+                    }),
+                ]))
+                    .min(1)
+                    .max(50),
+            }))
+                .max(500),
         }),
-    }, async (input) => toolResult(await service.taskSelfReview(input)));
+    }, async (input, context) => {
+        let questions;
+        try {
+            questions = service.ruleDeviationQuestions(input);
+        }
+        catch {
+            return toolResult(await service.taskSelfReview(input));
+        }
+        for (const { definition, previousDefinitions } of questions) {
+            const form = await askQuestionnaire(server, service, { ...definition, repoRoot: input.repoRoot }, context, previousDefinitions);
+            if (!answerChoice(form))
+                return form;
+        }
+        return toolResult(await service.taskSelfReview(input));
+    });
     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. A pending result is a durable local receipt; continue independent work without polling. Required delivery is checked before verification.',
+        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.',
         inputSchema: z
             .object({
             repoRoot: optionalRepoRoot,
@@ -464,10 +528,10 @@ export function registerEngineeringMemoryTools(server, service) {
                 return;
             }
             for (const entry of entries) {
-                if (entry.type === 'approved_revision' && (!entry.proposalId || !entry.revisionId)) {
+                if (entry.type === 'approved_revision' && !entry.proposalId) {
                     context.addIssue({
                         code: 'custom',
-                        message: 'Approved reconciliation requires proposalId and revisionId',
+                        message: 'Approved reconciliation requires proposalId',
                     });
                 }
                 if (entry.type === 'no_semantic_memory_change' &&
@@ -498,11 +562,15 @@ export function registerEngineeringMemoryTools(server, service) {
         }),
     }, async (input) => toolResult(await service.taskResolvePendingDelivery(input)));
     server.registerTool('task.verify', {
-        description: 'Verify a write task with its lease or a read-only task against its pinned Git baseline, mandatory checkpoints, structured validations and synchronized outbox.',
+        description: 'Verify a write task with its lease or a read-only task against its pinned Git baseline, mandatory checkpoints, structured validations and synchronized outbox. A refusal lists every unmet requirement at once. If the user decides a required check is not needed for this task, pass it in waivers; the tool asks them natively and records the answer.',
         inputSchema: z.object({
             repoRoot: optionalRepoRoot,
             taskId: z.string().min(1),
             sessionId: z.string().min(1),
+            language: z
+                .enum(['tr', 'en'])
+                .optional()
+                .describe('Language of the current conversation, for the waiver question.'),
             leaseId: z.string().min(1).optional(),
             changedPaths: stringList.min(1).optional(),
             validations: z
@@ -525,8 +593,61 @@ export function registerEngineeringMemoryTools(server, service) {
                 .max(20)
                 .optional()
                 .describe('Architectural structures this task adds that the project did not have: a cache, a broker, a read replica, a second deployable, a projection, an event store. Verification refuses any the project profile has not recorded under architecture.adopted with the pressure it relieves.'),
-        }),
-    }, async (input) => toolResult(await service.taskVerify(input)));
+            waivers: z
+                .array(z.object({
+                validationId: z.enum(['ui']),
+                reason: z.string().min(10).max(500),
+            }))
+                .max(3)
+                .optional()
+                .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;
+        for (const waiver of request.waivers ?? []) {
+            const subject = await service.validationWaiverSubject({
+                repoRoot: request.repoRoot,
+                taskId: request.taskId,
+                sessionId: request.sessionId,
+                ...waiver,
+            });
+            if (!subject.ok)
+                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 = [
+                {
+                    questionnaireId,
+                    language: 'tr',
+                    message: `${externalTaskId}: Bu görev için arayüz (UI) kontrolü atlansın mı? Değişen şu dosyalar ekranda görünen arayüzü oluşturuyor: ${listed}. Belirtilen gerekçe: ${reason}. Görev, bu dosyaların widget, golden veya ekran görüntüsü testi olmadan doğrulanır. Karar görevin denetim kaydına yazılır.`,
+                    options: [
+                        { id: 'waive', label: 'Bu dosyalar için UI kontrolünü atla' },
+                        { id: 'require', label: 'UI kontrolü zorunlu kalsın' },
+                    ],
+                },
+                {
+                    questionnaireId,
+                    language: 'en',
+                    message: `${externalTaskId}: skip the UI check for this task? These changed files render UI: ${listed}. Reason given: ${reason}. The task will verify without a widget, golden or screenshot check of them. The decision is stored in the task's audit trail.`,
+                    options: [
+                        { id: 'waive', label: 'Skip the UI check for these files' },
+                        { id: 'require', label: 'Keep the UI check required' },
+                    ],
+                },
+            ];
+            const form = await askQuestionnaire(server, service, {
+                ...definitions.find((definition) => definition.language === language),
+                repoRoot: request.repoRoot,
+            }, context, definitions);
+            const record = await service.questionnaireResume({
+                repoRoot: request.repoRoot,
+                questionnaireId,
+            });
+            if (record.status !== 'answered' || record.answer?.choice !== 'waive')
+                return form;
+        }
+        return toolResult(await service.taskVerify(request));
+    });
     server.registerTool('task.close', {
         description: 'Close a task only when backend verification still matches the current Git diff hash.',
         inputSchema: z.object({
@@ -652,7 +773,7 @@ export function registerEngineeringMemoryTools(server, service) {
         inputSchema: z.object({ includeArchived: z.boolean().optional() }),
     }, async (input) => toolResult(await service.projectList(input)));
     server.registerTool('project.resolve', {
-        description: 'Resolve the current repository fingerprint or bind an explicitly selected project, then store the user-local binding only after backend authorization succeeds.',
+        description: 'Resolve the project this checkout belongs to, or bind an explicitly selected project, then store the user-local binding only after backend authorization succeeds. A result with projectMoved means this checkout points at a repository the project left; a bind refused with recovery project.move_repository means the project lives in another repository and an owner can move it here.',
         inputSchema: z.object({
             repoRoot: optionalRepoRoot,
             bind: z.boolean().optional(),