engineering-memory 1.10.4 → 1.10.5

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "engineering-memory",
-  "version": "1.10.4",
+  "version": "1.10.5",
   "description": "Installs the Engineering Memory skill and its local MCP bridge. Sign in after installing; your organization and project are resolved from your account.",
   "license": "UNLICENSED",
   "type": "module",

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

@@ -16,6 +16,42 @@ const json = z.lazy(() => z.union([
     z.record(z.string(), json),
 ]));
 const object = z.record(z.string(), json);
+const inspectionCopy = {
+    tr: {
+        modes: {
+            refresh: 'Projenin hafızasını güncel kodla karşılaştırıp incelemeyi başlatalım mı?',
+            adopt: 'Mevcut projeyi mimarisiyle birlikte öğrenmeye başlayalım mı?',
+            rework: 'Rework planından önce mevcut projeyi incelemeye başlayalım mı?',
+        },
+        source: 'Kaynak',
+        scope: 'Mimari, state yönetimi, servisler, network katmanı, veri modelleri, ekranlar ve akışlar incelenecek.',
+        localChanges: 'Uygulama kodu değiştirilmeyecek. Commit edilmemiş değişiklikler ortak hafızaya alınmayacak.',
+        review: 'Bu onay incelemeyi başlatır. Kalıcı hafıza değişiklikleri ayrıca onayına sunulacak.',
+        rework: {
+            preserve: 'Rework hedefi: mevcut davranışı korumak.',
+            redesign: 'Rework hedefi: ürünü yeniden tasarlamak. Uygulama öncesinde hedef ayrıca onaylanacak.',
+        },
+        start: 'İncelemeyi başlat',
+        defer: 'Şimdilik başlatma',
+    },
+    en: {
+        modes: {
+            refresh: 'Start comparing project memory with the current code?',
+            adopt: 'Start learning the existing project and its architecture?',
+            rework: 'Start inspecting the existing project before planning its rework?',
+        },
+        source: 'Source',
+        scope: 'Inspect architecture, state, services, network, data models, screens and flows.',
+        localChanges: 'Application code will stay unchanged. Uncommitted changes will not enter shared memory.',
+        review: 'This approval starts the inspection. Permanent memory changes will be submitted for separate approval.',
+        rework: {
+            preserve: 'Rework goal: preserve existing behavior.',
+            redesign: 'Rework goal: redesign the product. The target needs separate approval before implementation.',
+        },
+        start: 'Start inspection',
+        defer: 'Not now',
+    },
+};
 const reference = z.object({
     proposalId: uuid,
     contentHash: hash,
@@ -197,12 +233,16 @@ export function registerOnboardingTools(server, service) {
         }),
     }, async (input) => output(await service.memorySource(input)));
     server.registerTool('memory.sync_start', {
-        description: 'Start or resume an idempotent committed-source inspection after native mode approval. Uploads all manifest pages, including exclusions. Request key and source are immutable. Refresh references a completed earlier run; rework requires preserve/redesign. Analyze with the current agent; no backend LLM.',
+        description: 'Start or resume an idempotent committed-source inspection after native mode approval. Set language from the current conversation (tr or en), never from machine locale. Uploads all manifest pages, including exclusions. Request key and source are immutable. Refresh references a completed earlier run; rework requires preserve/redesign. Analyze with the current agent; no backend LLM.',
         inputSchema: z.object({
             ...project,
             repoRoot,
             requestKey: z.string().regex(/^[a-zA-Z0-9_-]{1,120}$/),
             mode: z.enum(['adopt', 'refresh', 'rework']),
+            language: z
+                .enum(['tr', 'en'])
+                .optional()
+                .describe('Use the current conversation language: tr for Turkish, en for English. Omitted by legacy callers means English.'),
             ref: z.string().optional(),
             previousRunId: uuid.optional(),
             reworkBehavior: z.enum(['preserve', 'redesign']).optional(),
@@ -226,24 +266,51 @@ export function registerOnboardingTools(server, service) {
                     recovery: 'memory.sync_status',
                 },
             });
-        const pinned = { ...input, ref: commit };
+        const { language = 'en', ...request } = input;
+        const pinned = { ...request, ref: commit };
         const digest = sha256(stableStringify(pinned));
-        const question = await askQuestionnaire(server, service, {
-            repoRoot: input.repoRoot,
-            questionnaireId: 'sync-start-' + digest,
-            message: 'Start ' +
-                input.mode +
-                ' for committed source ' +
-                commit +
-                '? Inspect architecture, state, services, network, data, screens and flows; dirty changes stay local. ' +
-                (input.reworkBehavior ? 'Rework target: ' + input.reworkBehavior + '. ' : '') +
-                'Exact request: ' +
-                digest,
-            options: [
-                { id: 'approve', label: 'Start this exact inspection' },
-                { id: 'defer', label: 'Keep inspection unstarted' },
-            ],
-        }, context);
+        const reference = input.ref ?? 'HEAD';
+        const sourceLabel = /^[0-9a-f]{40,64}$/i.test(reference)
+            ? commit.slice(0, 12)
+            : `${reference.slice(0, 80)} · ${commit.slice(0, 12)}`;
+        const definitions = ['tr', 'en'].map((displayLanguage) => {
+            const copy = inspectionCopy[displayLanguage];
+            return {
+                questionnaireId: 'sync-start-' + digest,
+                language: displayLanguage,
+                message: [
+                    copy.modes[input.mode],
+                    `${copy.source}: ${sourceLabel}`,
+                    copy.scope,
+                    copy.localChanges,
+                    copy.review,
+                    ...(input.reworkBehavior ? [copy.rework[input.reworkBehavior]] : []),
+                ].join('\n\n'),
+                options: [
+                    { id: 'approve', label: copy.start },
+                    { id: 'defer', label: copy.defer },
+                ],
+            };
+        });
+        const definition = definitions.find((entry) => entry.language === language);
+        const question = await askQuestionnaire(server, service, { ...definition, repoRoot: input.repoRoot }, context, [
+            ...definitions,
+            {
+                questionnaireId: 'sync-start-' + digest,
+                message: 'Start ' +
+                    input.mode +
+                    ' for committed source ' +
+                    commit +
+                    '? Inspect architecture, state, services, network, data, screens and flows; dirty changes stay local. ' +
+                    (input.reworkBehavior ? 'Rework target: ' + input.reworkBehavior + '. ' : '') +
+                    'Exact request: ' +
+                    digest,
+                options: [
+                    { id: 'approve', label: 'Start this exact inspection' },
+                    { id: 'defer', label: 'Keep inspection unstarted' },
+                ],
+            },
+        ]);
         if (answerChoice(question) !== 'approve')
             return question;
         return output(await service.memorySyncStart({ ...pinned, questionnaireId: 'sync-start-' + digest }));

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

@@ -1,8 +1,8 @@
 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) {
+export async function askQuestionnaire(server, service, input, context, previousDefinitions = []) {
     try {
-        return await present(server, service, await service.questionnaireAsk(input), input.repoRoot, context, input.preparation);
+        return await present(server, service, await service.questionnaireAsk(input, previousDefinitions), input.repoRoot, context, input.preparation);
     }
     catch (error) {
         return failure(error);
@@ -53,31 +53,32 @@ 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'];
     return inputRequired({
         inputRequests: {
             [record.requestKey]: inputRequired.elicit({
                 mode: 'form',
-                message: `${record.message}\n\nChoose an answer to resolve this decision. Closing or cancelling the form leaves it pending.${record.allowFreeText ? ' For another answer choose Other and fill in text. Free text is not stored and cannot be replayed.' : ''}${record.textField ? ' The bounded text field is stored as part of this exact decision and is replayed after restart.' : ''}`,
+                message: `${record.message}\n\n${copy.pending}${record.allowFreeText ? copy.freeText : ''}${record.textField ? copy.storedText : ''}`,
                 requestedSchema: {
                     type: 'object',
                     properties: {
                         choice: {
                             type: 'string',
-                            title: 'Answer',
+                            title: copy.answer,
                             enum: [
                                 ...record.options.map((option) => option.id),
                                 ...(record.allowFreeText ? ['__other__'] : []),
                             ],
                             enumNames: [
                                 ...record.options.map((option) => option.label),
-                                ...(record.allowFreeText ? ['Other'] : []),
+                                ...(record.allowFreeText ? [copy.other] : []),
                             ],
                         },
                         ...(record.allowFreeText
                             ? {
                                 text: {
                                     type: 'string',
-                                    title: 'Other answer',
+                                    title: copy.otherAnswer,
                                     minLength: 1,
                                     maxLength: 2000,
                                 },
@@ -100,6 +101,24 @@ async function present(server, service, record, repoRoot, context, preparation)
         },
     });
 }
+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.',
+        answer: 'Answer',
+        other: 'Other',
+        otherAnswer: 'Other answer',
+    },
+    tr: {
+        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.',
+        answer: 'Yanıt',
+        other: 'Diğer',
+        otherAnswer: 'Diğer yanıt',
+    },
+};
 function pending(record, reason) {
     return result({
         questionnaireId: record.questionnaireId,

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

@@ -171,7 +171,7 @@ export function registerQuestionnaireTools(server, service) {
         }
     });
     server.registerTool('questionnaire.ask', {
-        description: 'Persist a required decision before displaying a native questionnaire. 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 tool arguments. 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 tool arguments. 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.',
         inputSchema: questionnaireDefinitionSchema.extend({
             repoRoot: optionalRepoRoot,
             preparation: z.boolean().optional(),

package/runtime/dist/src/runtime/bridge-service.js

@@ -36,10 +36,10 @@ export class BridgeService {
         this.dependencies = dependencies;
         this.deferDeliveries = dependencies.deferDeliveries ?? true;
     }
-    async questionnaireAsk(input) {
+    async questionnaireAsk(input, previousDefinitions = []) {
         const scope = await this.questionnaireScope(input.repoRoot, input.preparation);
         const { repoRoot: _repoRoot, preparation: _preparation, ...definition } = input;
-        return await this.dependencies.questionnaires.ask(scope, definition);
+        return await this.dependencies.questionnaires.ask(scope, definition, previousDefinitions);
     }
     async questionnaireResume(input) {
         const scope = await this.questionnaireScope(input.repoRoot, input.preparation);

package/runtime/dist/src/runtime/questionnaire-store.js

@@ -9,6 +9,10 @@ const identifier = z.string().regex(/^[A-Za-z0-9_-]{1,100}$/);
 export const questionnaireDefinitionSchema = z.strictObject({
     questionnaireId: identifier,
     message: z.string().trim().min(1).max(2000),
+    language: z
+        .enum(['tr', 'en'])
+        .optional()
+        .describe('Language of the current conversation: tr for Turkish, en for English. Translate the message and option labels into that language too.'),
     options: z
         .array(z.strictObject({
         id: z
@@ -97,8 +101,14 @@ export class QuestionnaireStore {
     constructor(stateRoot) {
         this.root = join(stateRoot, 'questionnaires');
     }
-    async ask(scope, input) {
+    async ask(scope, input, previousDefinitions = []) {
         const definition = questionnaireDefinitionSchema.parse(input);
+        const previousHashes = previousDefinitions.map((previous) => {
+            const parsed = questionnaireDefinitionSchema.parse(previous);
+            if (parsed.questionnaireId !== definition.questionnaireId)
+                throw new Error('Previous questionnaire content must belong to the same decision.');
+            return sha256(stableStringify(parsed));
+        });
         scopeSchema.parse(scope);
         assertSafeToPersist(definition);
         const contentHash = sha256(stableStringify(definition));
@@ -112,7 +122,8 @@ export class QuestionnaireStore {
         };
         await this.publish(this.pathFor(scope, definition.questionnaireId, 'pending.json'), question);
         const record = await this.get(scope, definition.questionnaireId);
-        if (!record || record.contentHash !== contentHash) {
+        if (!record ||
+            (record.contentHash !== contentHash && !previousHashes.includes(record.contentHash))) {
             throw new Error('Questionnaire id was reused with different content. Resume the original question or use a new id.');
         }
         return record;
@@ -125,6 +136,7 @@ export class QuestionnaireStore {
         const definition = questionnaireDefinitionSchema.parse({
             questionnaireId: question.questionnaireId,
             message: question.message,
+            language: question.language,
             options: question.options,
             allowFreeText: question.allowFreeText,
             textField: question.textField,

package/skill/references/project-onboarding.md

@@ -144,3 +144,16 @@ gates. Cross-project phases use existing work_item.plan/confirm_plan with explic
 and independent per-repository runs. Planning tasks does not perform their implementation.
 
 A deferred individual field or final profile saves no onboarding choice. Retrying that request preserves its deferral. When the user explicitly resumes, use the returned `nextRequestKey` for fresh native decisions; never infer approval from a previous defer.
+
+## Inspection confirmation language
+
+For memory.sync_start, pass language: tr in a Turkish conversation and language: en in an English
+conversation. Use the conversation language, never the computer locale. Legacy calls without language
+use English. The form shows a short source reference, scope, the treatment of uncommitted changes and
+the separate approval needed for permanent memory. Full commit and request hashes stay in the durable
+approval binding, not in the visible question. Generic questionnaire.ask messages and option labels
+are written by the agent in the same language; pass language for the native help and field labels.
+
+An existing exact-request questionnaire retains its original wording and answer across updates and
+restart, including an older English form. Resume that question rather than silently replacing or
+withdrawing it. Language changes never broaden the approved source, mode or previous-run scope.

package/skill/references/questionnaires.md

@@ -239,3 +239,16 @@ again.
 `project.onboard` can save the profile before initialization. Calling `project.initialize` with the
 same request key reuses the profile answers and asks a separate exact Git-initialization confirmation.
 Saving a profile does not authorize filesystem initialization.
+
+## Inspection confirmation language
+
+For memory.sync_start, pass language: tr in a Turkish conversation and language: en in an English
+conversation. Use the conversation language, never the computer locale. Legacy calls without language
+use English. The form shows a short source reference, scope, the treatment of uncommitted changes and
+the separate approval needed for permanent memory. Full commit and request hashes stay in the durable
+approval binding, not in the visible question. Generic questionnaire.ask messages and option labels
+are written by the agent in the same language; pass language for the native help and field labels.
+
+An existing exact-request questionnaire retains its original wording and answer across updates and
+restart, including an older English form. Resume that question rather than silently replacing or
+withdrawing it. Language changes never broaden the approved source, mode or previous-run scope.