engineering-memory 1.11.8 → 1.11.10

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/server.js

@@ -2,17 +2,24 @@ import { registerWorktreeTools } from './worktree-tools.js';
 import { McpServer } from '@modelcontextprotocol/server';
 import { registerOnboardingTools } from './onboarding-tools.js';
 import { registerEngineeringMemoryTools, registerQuestionnaireTools } from './tool-definitions.js';
-export function createEngineeringMemoryServer(service) {
-    const server = new McpServer({
+export const serverInstructions = 'Start with session.entry and follow the returned lifecycle. Do not block independent task work on memory.propose_revision drafting, submission or approval. If the host permits background agents or concurrent calls, dispatch independent proposals and continue useful work; otherwise checkpoint the draft and defer submission until needed. Checkpoint, correction, reconciliation, self-review and scaffold receipts use the durable local outbox; after deliveryStatus pending, continue independent work without polling or resending. Inventory upload, claim-bound evidence submission and test-result reporting may overlap independent analysis using host-permitted concurrent calls. Wait only when the next operation needs the result; required task deliveries must settle before verification. Preserve task/source identity and native user approval; never treat pending work as verified.';
+export function createMcpServer() {
+    return new McpServer({
         name: 'engineering-memory',
         version: '0.1.0',
     }, {
-        instructions: 'Start with session.entry and follow the returned lifecycle. Do not block independent task work on memory.propose_revision drafting, submission or approval. If the host permits background agents or concurrent calls, dispatch independent proposals and continue useful work; otherwise checkpoint the draft and defer submission until needed. Checkpoint, correction, reconciliation, self-review and scaffold receipts use the durable local outbox; after deliveryStatus pending, continue independent work without polling or resending. Inventory upload, claim-bound evidence submission and test-result reporting may overlap independent analysis using host-permitted concurrent calls. Wait only when the next operation needs the result; required task deliveries must settle before verification. Preserve task/source identity and native user approval; never treat pending work as verified.',
+        instructions: serverInstructions,
     });
-    registerEngineeringMemoryTools(server, service);
-    registerQuestionnaireTools(server, service);
-    registerOnboardingTools(server, service);
-    registerWorktreeTools(server, service);
+}
+export function registerAllTools(host, service) {
+    registerEngineeringMemoryTools(host, service);
+    registerQuestionnaireTools(host, service);
+    registerOnboardingTools(host, service);
+    registerWorktreeTools(host, service);
+}
+export function createEngineeringMemoryServer(service) {
+    const server = createMcpServer();
+    registerAllTools(server, service);
     return server;
 }
 //# sourceMappingURL=server.js.map

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

@@ -0,0 +1,111 @@
+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.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